Head

GCC Code Coverage Report
Directory:	./		Exec	Total	Coverage
File:	usr.sbin/smtpd/smtpctl/parse.c	Lines:	0	730	0.0 %
Date:	2017-11-07	Branches:	0	541	0.0 %

#include <stdlib.h>
#include <string.h>
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define YYLEX yylex()
#define YYEMPTY -1
#define yyclearin (yychar=(YYEMPTY))
#define yyerrok (yyerrflag=0)
#define YYRECOVERING() (yyerrflag!=0)
#define YYPREFIX "yy"
#line 25 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
#include <sys/types.h>
#include <sys/queue.h>
#include <sys/tree.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/ioctl.h>

#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <event.h>
#include <ifaddrs.h>
#include <imsg.h>
#include <inttypes.h>
#include <limits.h>
#include <netdb.h>
#include <paths.h>
#include <pwd.h>
#include <resolv.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <util.h>

#include <openssl/ssl.h>

#include "smtpd.h"
#include "ssl.h"
#include "log.h"

TAILQ_HEAD(files, file)		 files = TAILQ_HEAD_INITIALIZER(files);
static struct file {
	TAILQ_ENTRY(file)	 entry;
	FILE			*stream;
	char			*name;
	int			 lineno;
	int			 errors;
} *file, *topfile;
struct file	*pushfile(const char *, int);
int		 popfile(void);
int		 check_file_secrecy(int, const char *);
int		 yyparse(void);
int		 yylex(void);
int		 kw_cmp(const void *, const void *);
int		 lookup(char *);
int		 lgetc(int);
int		 lungetc(int);
int		 findeol(void);
int		 yyerror(const char *, ...)
    __attribute__((__format__ (printf, 1, 2)))
    __attribute__((__nonnull__ (1)));

TAILQ_HEAD(symhead, sym)	 symhead = TAILQ_HEAD_INITIALIZER(symhead);
struct sym {
	TAILQ_ENTRY(sym)	 entry;
	int			 used;
	int			 persist;
	char			*nam;
	char			*val;
};
int		 symset(const char *, const char *, int);
char		*symget(const char *);

struct smtpd		*conf = NULL;
static int		 errors = 0;
static uint64_t		 ruleid = 0;

struct filter_conf	*filter = NULL;
struct table		*table = NULL;
struct rule		*rule = NULL;
struct mta_limits	*limits;
static struct pki	*pki;
static struct ca	*sca;

enum listen_options {
	LO_FAMILY	= 0x000001,
	LO_PORT		= 0x000002,
	LO_SSL		= 0x000004,
	LO_FILTER      	= 0x000008,
	LO_PKI      	= 0x000010,
	LO_AUTH      	= 0x000020,
	LO_TAG      	= 0x000040,
	LO_HOSTNAME   	= 0x000080,
	LO_HOSTNAMES   	= 0x000100,
	LO_MASKSOURCE  	= 0x000200,
	LO_NODSN	= 0x000400,
	LO_SENDERS	= 0x000800,
	LO_RECEIVEDAUTH = 0x001000,
	LO_MASQUERADE	= 0x002000,
	LO_CA		= 0x010000
};

static struct listen_opts {
	char	       *ifx;
	int		family;
	in_port_t	port;
	uint16_t	ssl;
	char	       *filtername;
	char	       *pki;
	char	       *ca;
	uint16_t       	auth;
	struct table   *authtable;
	char	       *tag;
	char	       *hostname;
	struct table   *hostnametable;
	struct table   *sendertable;
	uint16_t	flags;

	uint32_t       	options;
} listen_opts;

static void	create_sock_listener(struct listen_opts *);
static void	create_if_listener(struct listen_opts *);
static void	config_listener(struct listener *, struct listen_opts *);
static int	host_v4(struct listen_opts *);
static int	host_v6(struct listen_opts *);
static int	host_dns(struct listen_opts *);
static int	interface(struct listen_opts *);

void		 set_local(const char *);
void		 set_localaddrs(struct table *);
int		 delaytonum(char *);
int		 is_if_in_group(const char *, const char *);

static int config_lo_filter(struct listen_opts *, char *);
static int config_lo_mask_source(struct listen_opts *);

typedef struct {
	union {
		int64_t		 number;
		struct table	*table;
		char		*string;
		struct host	*host;
		struct mailaddr	*maddr;
	} v;
	int lineno;
} YYSTYPE;

#line 158 "parse.c"
#define AS 257
#define QUEUE 258
#define COMPRESSION 259
#define ENCRYPTION 260
#define MAXMESSAGESIZE 261
#define MAXMTADEFERRED 262
#define LISTEN 263
#define ON 264
#define ANY 265
#define PORT 266
#define EXPIRE 267
#define TABLE 268
#define SMTPS 269
#define CERTIFICATE 270
#define DOMAIN 271
#define BOUNCEWARN 272
#define LIMIT 273
#define INET4 274
#define INET6 275
#define NODSN 276
#define SESSION 277
#define RELAY 278
#define BACKUP 279
#define VIA 280
#define DELIVER 281
#define TO 282
#define LMTP 283
#define MAILDIR 284
#define MBOX 285
#define RCPTTO 286
#define HOSTNAME 287
#define HOSTNAMES 288
#define ACCEPT 289
#define REJECT 290
#define INCLUDE 291
#define ERROR 292
#define MDA 293
#define FROM 294
#define FOR 295
#define SOURCE 296
#define MTA 297
#define PKI 298
#define SCHEDULER 299
#define ARROW 300
#define AUTH 301
#define TLS 302
#define LOCAL 303
#define VIRTUAL 304
#define TAG 305
#define TAGGED 306
#define ALIAS 307
#define FILTER 308
#define KEY 309
#define CA 310
#define DHE 311
#define AUTH_OPTIONAL 312
#define TLS_REQUIRE 313
#define USERBASE 314
#define SENDER 315
#define SENDERS 316
#define MASK_SOURCE 317
#define VERIFY 318
#define FORWARDONLY 319
#define RECIPIENT 320
#define CIPHERS 321
#define RECEIVEDAUTH 322
#define MASQUERADE 323
#define SOCKET 324
#define SUBADDRESSING_DELIM 325
#define AUTHENTICATED 326
#define STRING 327
#define NUMBER 328
#define YYERRCODE 256
const short yylhs[] =
	{                                        -1,
    0,    0,    0,    0,    0,    0,    0,    0,   11,   12,
   15,   15,   15,   17,   17,   16,    2,    2,   10,   18,
   19,   20,   20,   20,   21,   22,   22,   23,   24,   24,
   25,   25,   25,   26,   26,   27,   28,   28,   29,   30,
   31,   31,   31,   32,   32,   33,   33,   34,   34,   34,
   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
   34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
   34,   35,   35,   36,   37,   38,   38,   39,   39,   40,
   40,   40,   40,   40,   40,   41,   41,   41,   41,   42,
   42,   42,   43,   43,   44,   44,   44,   45,   13,   13,
   13,   13,   13,   13,   13,   13,   13,   13,   46,   13,
   47,   13,   13,   48,   13,   49,   13,   50,   13,   13,
    1,   51,    1,   53,   53,   54,   55,   55,   56,   57,
   57,   52,   52,    5,   58,    5,    6,    4,    4,    7,
    8,   59,   59,    9,   60,   60,   61,   61,   61,   61,
   61,   61,   62,   63,   62,    3,    3,   64,   64,   64,
   65,   65,   65,   66,   67,   68,   69,   70,   70,   70,
   70,   70,   70,   71,   71,   72,   72,   73,   73,   74,
   74,   74,   75,   75,   76,   76,   77,   14,   78,   14,
};
const short yylen[] =
	{                                         2,
    0,    2,    3,    3,    3,    3,    3,    3,    2,    3,
    1,    1,    0,    2,    0,    2,    1,    1,    3,    2,
    1,    3,    1,    0,    2,    2,    0,    2,    2,    0,
    1,    1,    2,    2,    0,    2,    2,    0,    2,    1,
    2,    2,    2,    2,    0,    2,    1,    1,    1,    2,
    2,    2,    1,    2,    1,    1,    2,    2,    2,    1,
    1,    2,    2,    2,    2,    2,    1,    1,    1,    2,
    3,    1,    1,    2,    2,    2,    0,    2,    0,    2,
    2,    2,    2,    2,    2,    2,    1,    1,    2,    2,
    2,    0,    2,    1,    2,    2,    0,    0,    3,    2,
    2,    2,    4,    2,    2,    2,    3,    3,    0,    7,
    0,    4,    3,    0,    4,    0,    4,    0,    4,    2,
    3,    0,    6,    1,    1,    3,    1,    3,    1,    1,
    3,    1,    1,    1,    0,    4,    3,    1,    1,    2,
    2,    1,    1,    2,    2,    0,    3,    4,    3,    5,
    6,    5,    2,    0,    5,    1,    0,    4,    3,    3,
    4,    3,    3,    3,    3,    1,    2,    1,    1,    1,
    1,    1,    1,    2,    0,    1,    1,    2,    0,    1,
    1,    0,    1,    1,    2,    0,    0,    6,    0,    3,
};
const short yydefred[] =
	{                                      1,
    0,    0,    0,    0,    0,  114,    0,    0,   98,    0,
  187,  189,    0,    0,    0,    0,    0,    0,    2,    0,
    0,    0,    0,    0,    8,  101,    0,   18,   17,  105,
  106,    0,  104,    0,    0,    0,    0,    0,    0,    0,
    0,    9,  116,  118,  120,  100,    0,    6,    3,    4,
    5,    7,    0,    0,  121,    0,   21,   23,    0,    0,
  107,    0,    0,    0,  108,    0,    0,    0,    0,  113,
    0,    0,    0,    0,    0,  156,    0,  172,  173,  170,
  171,  168,  169,    0,    0,  190,    0,    0,   10,  103,
    0,    0,  115,   72,   73,    0,    0,   28,   26,   25,
   29,    0,   31,   32,    0,    0,  112,   36,   37,    0,
    0,    0,    0,    0,   20,  174,    0,    0,    0,  142,
  143,  176,  177,    0,    0,    0,    0,    0,    0,  117,
    0,   40,  119,    0,   47,    0,   74,    0,    0,   48,
   49,   69,    0,    0,    0,    0,   55,    0,    0,    0,
    0,    0,    0,   67,   68,    0,   75,    0,    0,    0,
  133,    0,  132,   22,  109,   33,   34,  159,    0,  160,
  162,    0,  163,   19,  134,  135,    0,  164,  138,  139,
  165,  141,  140,  144,  178,    0,    0,  180,  181,    0,
   41,   42,   43,   44,   39,   46,   76,   50,   51,   54,
   65,   66,   58,   62,   64,   52,   59,   63,   57,    0,
   78,  125,  124,    0,  123,    0,   11,    0,   12,    0,
    0,  158,  161,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,  153,    0,    0,  166,
  184,  183,    0,  188,   71,  126,    0,   16,    0,  128,
  129,  131,  110,    0,  137,   80,   86,  154,   82,   83,
   81,   84,   89,   85,   90,   91,    0,    0,  149,    0,
  167,  185,   14,  136,    0,    0,  148,    0,    0,   94,
    0,    0,  155,    0,    0,  150,  152,   93,   95,   96,
  145,  151,
};
const short yydgoto[] =
	{                                       1,
   20,   30,   77,  178,  179,  180,  120,  121,  122,   78,
   21,   22,   23,   24,  218,  219,  248,   79,   58,   59,
   64,   61,   62,   65,  106,  107,   69,   70,  132,  133,
  129,  130,  136,  156,   93,   94,   95,  137,  157,  235,
  236,  237,  282,  283,   35,  221,   67,   32,   87,   88,
   56,  159,  214,  160,  161,  162,  163,  224,  123,  286,
  188,  189,  275,   80,   81,   82,   83,  241,  242,   84,
   85,  124,  125,  190,  243,  244,   40,   41,
};
const short yysindex[] =
	{                                      0,
  -10,   23, -202, -219, -290,    0, -292, -268,    0, -201,
    0,    0, -245, -241, -236, -230, -227,   49,    0,  113,
  115,  122,  124,  127,    0,    0, -167,    0,    0,    0,
    0, -117,    0, -177, -174, -172, -166, -135, -165,    8,
    8,    0,    0,    0,    0,    0, -163,    0,    0,    0,
    0,    0, -162, -293,    0,   28,    0,    0,  123, -160,
    0, -172, -159, -166,    0, -101, -255, -156, -165,    0,
  140,  140,  140,  140,  140,    0, -152,    0,    0,    0,
    0,    0,    0,    8, -200,    0, -247,  -95,    0,    0,
 -269, -186,    0,    0,    0, -151, -174,    0,    0,    0,
    0, -143,    0,    0, -145, -255,    0,    0,    0, -251,
 -243, -142,  -54,  -54,    0,    0,  -54,  -54,  -54,    0,
    0,    0,    0, -200, -194, -141, -140, -138, -247,    0,
 -137,    0,    0, -136,    0, -269,    0, -189, -130,    0,
    0,    0, -134,  -54, -133,  -54,    0, -132, -131, -129,
  -54, -126,  -54,    0,    0, -186,    0,  -53,   72,   17,
    0,   17,    0,    0,    0,    0,    0,    0,  -54,    0,
    0,  -54,    0,    0,    0,    0, -128,    0,    0,    0,
    0,    0,    0,    0,    0, -139,  -82,    0,    0, -246,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0, -121,
    0,    0,    0, -124,    0,  194,    0, -122,    0, -120,
 -255,    0,    0, -151,  144, -119, -118, -114, -113,  -54,
  -54, -112, -108, -111, -144, -144,    0, -190, -110,    0,
    0,    0, -246,    0,    0,    0,  194,    0,  -53,    0,
    0,    0,    0,   93,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0, -107, -106,    0, -105,
    0,    0,    0,    0, -233, -207,    0,  -38,  -54,    0,
 -233, -233,    0, -104,  -38,    0,    0,    0,    0,    0,
    0,    0,};
const short yyrindex[] =
	{                                      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,  214,    0,    0,    0,
    0,    0,    0,  102,   37,  216,  217,   -9,  218,   -6,
   -5,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  219,    0,
    0,  216,    0,  217,    0,    0,  220,    0,  218,    0,
 -225, -228,  -96,  -49,  -49,    0,    0,    0,    0,    0,
    0,    0,    0,   -6,   -7,    0,  222,    0,    0,    0,
  223,  224,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  220,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,   -7,   15,    0,    0,    0,  222,    0,
    0,    0,    0,    0,    0,  223,    0,    0,   56,    0,
    0,    0,    0,    0,    0,  101,    0,    0,    0,    0,
  146,  191,    0,    0,    0,  224,    0,   -8,    0, -116,
    0, -115,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,   16,    0,    0,    0,  225,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,  240,
    0,    0,    0,    0,    0,  -91,    0,    0,    0,    0,
  220,    0,    0,    0,    0,    0,   -3,    0,    0,    0,
    0,    0,  267,    0,   16,   16,    0,    0,    0,    0,
    0,    0,  225,    0,    0,    0,  -91,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   19,    0,    0,
    0,    0,    0,    0,   20,   22,    0,   22,    0,    0,
   20,   20,    0,    0,   22,    0,    0,    0,    0,    0,
    0,    0,};
const short yygindex[] =
	{                                      0,
    0,    0,  107, -102,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,   75,    0,   -4,    0,  141,    0,
    0,  177,    0,  176,    0,  -88,    0,  172,    0,    0,
    0,  116,    0,    0,    0,    0,    0,  106,   88, -176,
    0,  -90,    0, -161,    0,    0,    0,    0,    0,    0,
    0,   25,    0,    0,   38,    0,   35,    0,    0, -232,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  -28,    0,  135,    0,    0,   24,    0,    0,
};
#define YYTABLESIZE 586
const short yytable[] =
	{                                      19,
  111,  129,  179,  175,  175,  177,   87,  213,  127,  130,
  157,  181,   86,  168,  182,  183,  184,  167,  103,  104,
  239,  171,  126,  226,  182,   92,  216,  172,  147,   97,
   91,  146,   25,   92,   33,  129,  157,   31,  134,  157,
   76,  202,  157,  204,  169,  287,   24,  135,  208,  284,
  210,  170,  292,  229,  230,  116,   26,   27,   34,  173,
  217,  127,  231,  128,  232,   53,  222,  279,  176,  223,
  157,  105,  240,  157,  157,   36,  234,  157,  285,  138,
   24,   42,  139,  186,  280,   43,  187,  140,  141,  142,
   44,   37,  267,  268,  269,   38,   45,   39,  281,   46,
  143,  144,  270,  117,  281,  281,  118,   28,   29,   47,
   60,  145,  226,  119,  146,  147,  129,  226,  148,  289,
  290,  149,   48,  150,   49,  151,  152,  260,  261,  153,
  154,   50,  253,   51,  227,  155,   52,  198,  199,  227,
  228,   53,  229,  230,  265,  266,   54,  229,  230,   55,
   96,  231,   57,  232,   60,   61,  231,  233,  232,   66,
   63,   68,  233,   89,   90,  234,   97,   98,  100,  102,
  234,  108,   76,  115,  131,  158,  288,  110,  111,  112,
  113,  114,  166,  165,  174,  191,  192,  200,  193,  195,
  196,  209,  201,  203,  205,  206,  215,  207,  225,  238,
   56,  245,  246,  247,  249,  255,  251,  256,  257,  263,
   13,   13,  258,  259,  262,  264,  271,  274,  284,  276,
  277,  278,  291,  102,  122,   27,   30,   38,   99,   35,
  157,   45,   77,   79,  186,   15,  220,  164,   99,  101,
  109,  197,  273,  211,  194,    2,  212,    3,  254,   70,
    4,    5,    6,   87,  252,  250,    7,    8,  185,  179,
  175,    9,   10,   87,  111,  111,  272,    0,    0,    0,
  179,  175,  175,  179,  175,   87,   88,  157,   11,   12,
   13,  182,   92,   87,   87,  147,   97,   14,  146,    0,
    0,    0,   87,    0,   87,    0,    0,  175,   87,   15,
  175,   71,   72,    0,    0,    0,   87,  175,    0,    0,
   16,  179,  175,   73,   17,   87,   18,  111,  129,  157,
  157,   53,   74,    0,   53,    0,    0,   75,    0,   53,
   53,   53,    0,  182,   92,    0,    0,  147,   97,    0,
  146,    0,   53,   53,    0,    0,    0,    0,    0,    0,
    0,    0,    0,   53,    0,    0,   53,   53,    0,    0,
   53,    0,    0,   53,    0,   53,   60,   53,   53,   60,
    0,   53,   53,    0,   60,   60,   60,   53,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   60,   60,    0,
    0,    0,    0,    0,    0,    0,    0,    0,   60,    0,
    0,   60,   60,    0,    0,   60,    0,    0,   60,    0,
   60,   61,   60,   60,   61,    0,   60,   60,    0,   61,
   61,   61,   60,    0,    0,    0,    0,    0,    0,    0,
    0,    0,   61,   61,    0,    0,    0,    0,    0,    0,
    0,    0,    0,   61,    0,    0,   61,   61,    0,    0,
   61,    0,    0,   61,    0,   61,   56,   61,   61,   56,
    0,   61,   61,    0,   56,   56,   56,   61,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   56,   56,    0,
    0,    0,    0,    0,    0,    0,    0,    0,   56,    0,
    0,   56,   56,    0,    0,   56,    0,    0,   56,    0,
   56,    0,   56,   56,    0,   70,   56,   56,   70,    0,
    0,    0,   56,   70,   70,   70,    0,    0,    0,    0,
    0,    0,    0,   88,    0,    0,   70,   70,    0,    0,
    0,    0,    0,   88,    0,    0,    0,   70,    0,    0,
   70,   70,    0,    0,   70,   88,    0,   70,    0,   70,
    0,   70,   70,   88,   88,   70,   70,    0,    0,    0,
    0,   70,   88,    0,   88,    0,    0,    0,   88,    0,
    0,    0,    0,    0,    0,    0,   88,    0,    0,    0,
    0,    0,    0,    0,    0,   88,
};
const short yycheck[] =
	{                                      10,
   10,   10,   10,   10,   10,   60,   10,   61,  125,  125,
   60,  114,   41,  265,  117,  118,  119,  106,  274,  275,
  267,  265,  270,  257,   10,   10,   10,  271,   10,   10,
  324,   10,   10,  327,  327,   44,  265,  328,  308,  265,
   33,  144,  271,  146,  296,  278,   10,  317,  151,  257,
  153,  303,  285,  287,  288,   84,  259,  260,  327,  303,
   44,  309,  296,  311,  298,   10,  169,  301,  123,  172,
  296,  327,  319,  123,  303,  277,  310,  303,  286,  266,
   44,  327,  269,  278,  318,  327,  281,  274,  275,  276,
  327,  293,  283,  284,  285,  297,  327,  299,  275,  327,
  287,  288,  293,  304,  281,  282,  307,  327,  328,   61,
   10,  298,  257,  314,  301,  302,  125,  257,  305,  281,
  282,  308,   10,  310,   10,  312,  313,  230,  231,  316,
  317,   10,  221,   10,  279,  322,   10,  327,  328,  279,
  280,  309,  287,  288,  235,  236,  264,  287,  288,  327,
  123,  296,  327,  298,  327,   10,  296,  302,  298,  295,
  327,  327,  302,  327,  327,  310,   44,  328,  328,  271,
  310,  328,   33,  326,  270,  327,  279,   71,   72,   73,
   74,   75,  328,  327,  327,  327,  327,  318,  327,  327,
  327,  318,  327,  327,  327,  327,  125,  327,  327,  282,
   10,  323,  327,   10,  327,   62,  327,  327,  327,  318,
  327,  327,  327,  327,  327,  327,  327,  125,  257,  327,
  327,  327,  327,   10,  123,   10,   10,   10,   10,   10,
  327,   10,   10,   10,   10,  327,  162,   97,   62,   64,
   69,  136,  247,  156,  129,  256,  300,  258,  224,   10,
  261,  262,  263,  257,  220,  218,  267,  268,  124,  267,
  267,  272,  273,  267,  274,  275,  243,   -1,   -1,   -1,
  278,  278,  327,  281,  281,  279,   10,  327,  289,  290,
  291,  267,  267,  287,  288,  267,  267,  298,  267,   -1,
   -1,   -1,  296,   -1,  298,   -1,   -1,  304,  302,  310,
  307,  294,  295,   -1,   -1,   -1,  310,  314,   -1,   -1,
  321,  319,  319,  306,  325,  319,  327,  327,  327,  326,
  326,  266,  315,   -1,  269,   -1,   -1,  320,   -1,  274,
  275,  276,   -1,  319,  319,   -1,   -1,  319,  319,   -1,
  319,   -1,  287,  288,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  298,   -1,   -1,  301,  302,   -1,   -1,
  305,   -1,   -1,  308,   -1,  310,  266,  312,  313,  269,
   -1,  316,  317,   -1,  274,  275,  276,  322,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  287,  288,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  298,   -1,
   -1,  301,  302,   -1,   -1,  305,   -1,   -1,  308,   -1,
  310,  266,  312,  313,  269,   -1,  316,  317,   -1,  274,
  275,  276,  322,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,  287,  288,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  298,   -1,   -1,  301,  302,   -1,   -1,
  305,   -1,   -1,  308,   -1,  310,  266,  312,  313,  269,
   -1,  316,  317,   -1,  274,  275,  276,  322,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  287,  288,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  298,   -1,
   -1,  301,  302,   -1,   -1,  305,   -1,   -1,  308,   -1,
  310,   -1,  312,  313,   -1,  266,  316,  317,  269,   -1,
   -1,   -1,  322,  274,  275,  276,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  257,   -1,   -1,  287,  288,   -1,   -1,
   -1,   -1,   -1,  267,   -1,   -1,   -1,  298,   -1,   -1,
  301,  302,   -1,   -1,  305,  279,   -1,  308,   -1,  310,
   -1,  312,  313,  287,  288,  316,  317,   -1,   -1,   -1,
   -1,  322,  296,   -1,  298,   -1,   -1,   -1,  302,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,  310,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,  319,
};
#define YYFINAL 1
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 328
#if YYDEBUG
const char * const yyname[] =
	{
"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",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,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,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,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,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,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,"AS","QUEUE","COMPRESSION","ENCRYPTION","MAXMESSAGESIZE","MAXMTADEFERRED",
"LISTEN","ON","ANY","PORT","EXPIRE","TABLE","SMTPS","CERTIFICATE","DOMAIN",
"BOUNCEWARN","LIMIT","INET4","INET6","NODSN","SESSION","RELAY","BACKUP","VIA",
"DELIVER","TO","LMTP","MAILDIR","MBOX","RCPTTO","HOSTNAME","HOSTNAMES","ACCEPT",
"REJECT","INCLUDE","ERROR","MDA","FROM","FOR","SOURCE","MTA","PKI","SCHEDULER",
"ARROW","AUTH","TLS","LOCAL","VIRTUAL","TAG","TAGGED","ALIAS","FILTER","KEY",
"CA","DHE","AUTH_OPTIONAL","TLS_REQUIRE","USERBASE","SENDER","SENDERS",
"MASK_SOURCE","VERIFY","FORWARDONLY","RECIPIENT","CIPHERS","RECEIVEDAUTH",
"MASQUERADE","SOCKET","SUBADDRESSING_DELIM","AUTHENTICATED","STRING","NUMBER",
};
const char * const yyrule[] =
	{"$accept : grammar",
"grammar :",
"grammar : grammar '\\n'",
"grammar : grammar include '\\n'",
"grammar : grammar varset '\\n'",
"grammar : grammar main '\\n'",
"grammar : grammar table '\\n'",
"grammar : grammar rule '\\n'",
"grammar : grammar error '\\n'",
"include : INCLUDE STRING",
"varset : STRING '=' STRING",
"comma : ','",
"comma : nl",
"comma :",
"optnl : '\\n' optnl",
"optnl :",
"nl : '\\n' optnl",
"size : NUMBER",
"size : STRING",
"tagged : TAGGED negation STRING",
"authenticated : negation AUTHENTICATED",
"bouncedelay : STRING",
"bouncedelays : bouncedelays ',' bouncedelay",
"bouncedelays : bouncedelay",
"bouncedelays :",
"opt_limit_mda : STRING NUMBER",
"limits_session : opt_limit_session limits_session",
"limits_session :",
"opt_limit_session : STRING NUMBER",
"limits_mda : opt_limit_mda limits_mda",
"limits_mda :",
"opt_limit_mta : INET4",
"opt_limit_mta : INET6",
"opt_limit_mta : STRING NUMBER",
"limits_mta : opt_limit_mta limits_mta",
"limits_mta :",
"opt_limit_scheduler : STRING NUMBER",
"limits_scheduler : opt_limit_scheduler limits_scheduler",
"limits_scheduler :",
"opt_ca : CERTIFICATE STRING",
"ca : opt_ca",
"opt_pki : CERTIFICATE STRING",
"opt_pki : KEY STRING",
"opt_pki : DHE STRING",
"pki : opt_pki pki",
"pki :",
"opt_sock_listen : FILTER STRING",
"opt_sock_listen : MASK_SOURCE",
"opt_if_listen : INET4",
"opt_if_listen : INET6",
"opt_if_listen : PORT STRING",
"opt_if_listen : PORT NUMBER",
"opt_if_listen : FILTER STRING",
"opt_if_listen : SMTPS",
"opt_if_listen : SMTPS VERIFY",
"opt_if_listen : TLS",
"opt_if_listen : TLS_REQUIRE",
"opt_if_listen : TLS_REQUIRE VERIFY",
"opt_if_listen : PKI STRING",
"opt_if_listen : CA STRING",
"opt_if_listen : AUTH",
"opt_if_listen : AUTH_OPTIONAL",
"opt_if_listen : AUTH tables",
"opt_if_listen : AUTH_OPTIONAL tables",
"opt_if_listen : TAG STRING",
"opt_if_listen : HOSTNAME STRING",
"opt_if_listen : HOSTNAMES tables",
"opt_if_listen : MASK_SOURCE",
"opt_if_listen : RECEIVEDAUTH",
"opt_if_listen : NODSN",
"opt_if_listen : SENDERS tables",
"opt_if_listen : SENDERS tables MASQUERADE",
"listener_type : socket_listener",
"listener_type : if_listener",
"socket_listener : SOCKET sock_listen",
"if_listener : STRING if_listen",
"sock_listen : opt_sock_listen sock_listen",
"sock_listen :",
"if_listen : opt_if_listen if_listen",
"if_listen :",
"opt_relay_common : AS STRING",
"opt_relay_common : SOURCE tables",
"opt_relay_common : HOSTNAME STRING",
"opt_relay_common : HOSTNAMES tables",
"opt_relay_common : PKI STRING",
"opt_relay_common : CA STRING",
"opt_relay : BACKUP STRING",
"opt_relay : BACKUP",
"opt_relay : TLS",
"opt_relay : TLS VERIFY",
"relay : opt_relay_common relay",
"relay : opt_relay relay",
"relay :",
"opt_relay_via : AUTH tables",
"opt_relay_via : VERIFY",
"relay_via : opt_relay_common relay_via",
"relay_via : opt_relay_via relay_via",
"relay_via :",
"$$1 :",
"main : BOUNCEWARN $$1 bouncedelays",
"main : SUBADDRESSING_DELIM STRING",
"main : QUEUE COMPRESSION",
"main : QUEUE ENCRYPTION",
"main : QUEUE ENCRYPTION KEY STRING",
"main : EXPIRE STRING",
"main : MAXMESSAGESIZE size",
"main : MAXMTADEFERRED NUMBER",
"main : LIMIT SESSION limits_session",
"main : LIMIT MDA limits_mda",
"$$2 :",
"main : LIMIT MTA FOR DOMAIN STRING $$2 limits_mta",
"$$3 :",
"main : LIMIT MTA $$3 limits_mta",
"main : LIMIT SCHEDULER limits_scheduler",
"$$4 :",
"main : LISTEN $$4 ON listener_type",
"$$5 :",
"main : PKI STRING $$5 pki",
"$$6 :",
"main : CA STRING $$6 ca",
"main : CIPHERS STRING",
"table : TABLE STRING STRING",
"$$7 :",
"table : TABLE STRING $$7 '{' tableval_list '}'",
"assign : '='",
"assign : ARROW",
"keyval : STRING assign STRING",
"keyval_list : keyval",
"keyval_list : keyval comma keyval_list",
"stringel : STRING",
"string_list : stringel",
"string_list : stringel comma string_list",
"tableval_list : string_list",
"tableval_list : keyval_list",
"tablenew : STRING",
"$$8 :",
"tablenew : '{' $$8 tableval_list '}'",
"tableref : '<' STRING '>'",
"tables : tablenew",
"tables : tableref",
"alias : ALIAS tables",
"virtual : VIRTUAL tables",
"usermapping : alias",
"usermapping : virtual",
"userbase : USERBASE tables",
"deliver_as : AS STRING",
"deliver_as :",
"deliver_action : DELIVER TO MAILDIR",
"deliver_action : DELIVER TO MAILDIR STRING",
"deliver_action : DELIVER TO MBOX",
"deliver_action : DELIVER TO LMTP STRING deliver_as",
"deliver_action : DELIVER TO LMTP STRING RCPTTO deliver_as",
"deliver_action : DELIVER TO MDA STRING deliver_as",
"relay_action : RELAY relay",
"$$9 :",
"relay_action : RELAY VIA STRING $$9 relay_via",
"negation : '!'",
"negation :",
"from : FROM negation SOURCE tables",
"from : FROM negation ANY",
"from : FROM negation LOCAL",
"for : FOR negation DOMAIN tables",
"for : FOR negation ANY",
"for : FOR negation LOCAL",
"sender : SENDER negation tables",
"recipient : RECIPIENT negation tables",
"forwardonly : FORWARDONLY",
"expire : EXPIRE STRING",
"opt_decision : sender",
"opt_decision : recipient",
"opt_decision : from",
"opt_decision : for",
"opt_decision : tagged",
"opt_decision : authenticated",
"decision : opt_decision decision",
"decision :",
"opt_lookup : userbase",
"opt_lookup : usermapping",
"lookup : opt_lookup lookup",
"lookup :",
"action : deliver_action",
"action : relay_action",
"action :",
"opt_accept : expire",
"opt_accept : forwardonly",
"accept_params : opt_accept accept_params",
"accept_params :",
"$$10 :",
"rule : ACCEPT $$10 decision lookup action accept_params",
"$$11 :",
"rule : REJECT $$11 decision",
};
#endif
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 10000
#define YYMAXDEPTH 10000
#endif
#endif
#define YYINITSTACKSIZE 200
/* LINTUSED */
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short *yyss;
short *yysslim;
YYSTYPE *yyvs;
unsigned int yystacksize;
int yyparse(void);
#line 1423 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"

struct keywords {
	const char	*k_name;
	int		 k_val;
};

int
yyerror(const char *fmt, ...)
{
	va_list		 ap;
	char		*msg;

	file->errors++;
	va_start(ap, fmt);
	if (vasprintf(&msg, fmt, ap) == -1)
		fatalx("yyerror vasprintf");
	va_end(ap);
	logit(LOG_CRIT, "%s:%d: %s", file->name, yylval.lineno, msg);
	free(msg);
	return (0);
}

int
kw_cmp(const void *k, const void *e)
{
	return (strcmp(k, ((const struct keywords *)e)->k_name));
}

int
lookup(char *s)
{
	/* this has to be sorted always */
	static const struct keywords keywords[] = {
		{ "accept",		ACCEPT },
		{ "alias",		ALIAS },
		{ "any",		ANY },
		{ "as",			AS },
		{ "auth",		AUTH },
		{ "auth-optional",     	AUTH_OPTIONAL },
		{ "authenticated",     	AUTHENTICATED },
		{ "backup",		BACKUP },
		{ "bounce-warn",	BOUNCEWARN },
		{ "ca",			CA },
		{ "certificate",	CERTIFICATE },
		{ "ciphers",		CIPHERS },
		{ "compression",	COMPRESSION },
		{ "deliver",		DELIVER },
		{ "dhe",		DHE },
		{ "domain",		DOMAIN },
		{ "encryption",		ENCRYPTION },
		{ "expire",		EXPIRE },
		{ "filter",		FILTER },
		{ "for",		FOR },
		{ "forward-only",      	FORWARDONLY },
		{ "from",		FROM },
		{ "hostname",		HOSTNAME },
		{ "hostnames",		HOSTNAMES },
		{ "include",		INCLUDE },
		{ "inet4",		INET4 },
		{ "inet6",		INET6 },
		{ "key",		KEY },
		{ "limit",		LIMIT },
		{ "listen",		LISTEN },
		{ "lmtp",		LMTP },
		{ "local",		LOCAL },
		{ "maildir",		MAILDIR },
		{ "mask-source",	MASK_SOURCE },
		{ "masquerade",		MASQUERADE },
		{ "max-message-size",  	MAXMESSAGESIZE },
		{ "max-mta-deferred",  	MAXMTADEFERRED },
		{ "mbox",		MBOX },
		{ "mda",		MDA },
		{ "mta",		MTA },
		{ "no-dsn",		NODSN },
		{ "on",			ON },
		{ "pki",		PKI },
		{ "port",		PORT },
		{ "queue",		QUEUE },
		{ "rcpt-to",		RCPTTO },
		{ "received-auth",     	RECEIVEDAUTH },
		{ "recipient",		RECIPIENT },
		{ "reject",		REJECT },
		{ "relay",		RELAY },
		{ "scheduler",		SCHEDULER },
		{ "sender",    		SENDER },
		{ "senders",   		SENDERS },
		{ "session",   		SESSION },
		{ "smtps",		SMTPS },
		{ "socket",		SOCKET },
		{ "source",		SOURCE },
		{ "subaddressing-delimiter",	SUBADDRESSING_DELIM },
		{ "table",		TABLE },
		{ "tag",		TAG },
		{ "tagged",		TAGGED },
		{ "tls",		TLS },
		{ "tls-require",       	TLS_REQUIRE },
		{ "to",			TO },
		{ "userbase",		USERBASE },
		{ "verify",		VERIFY },
		{ "via",		VIA },
		{ "virtual",		VIRTUAL },
	};
	const struct keywords	*p;

	p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
	    sizeof(keywords[0]), kw_cmp);

	if (p)
		return (p->k_val);
	else
		return (STRING);
}

#define MAXPUSHBACK	128

unsigned char	*parsebuf;
int		 parseindex;
unsigned char	 pushback_buffer[MAXPUSHBACK];
int		 pushback_index = 0;

int
lgetc(int quotec)
{
	int		c, next;

	if (parsebuf) {
		/* Read character from the parsebuffer instead of input. */
		if (parseindex >= 0) {
			c = parsebuf[parseindex++];
			if (c != '\0')
				return (c);
			parsebuf = NULL;
		} else
			parseindex++;
	}

	if (pushback_index)
		return (pushback_buffer[--pushback_index]);

	if (quotec) {
		if ((c = getc(file->stream)) == EOF) {
			yyerror("reached end of file while parsing "
			    "quoted string");
			if (file == topfile || popfile() == EOF)
				return (EOF);
			return (quotec);
		}
		return (c);
	}

	while ((c = getc(file->stream)) == '\\') {
		next = getc(file->stream);
		if (next != '\n') {
			c = next;
			break;
		}
		yylval.lineno = file->lineno;
		file->lineno++;
	}

	while (c == EOF) {
		if (file == topfile || popfile() == EOF)
			return (EOF);
		c = getc(file->stream);
	}
	return (c);
}

int
lungetc(int c)
{
	if (c == EOF)
		return (EOF);
	if (parsebuf) {
		parseindex--;
		if (parseindex >= 0)
			return (c);
	}
	if (pushback_index < MAXPUSHBACK-1)
		return (pushback_buffer[pushback_index++] = c);
	else
		return (EOF);
}

int
findeol(void)
{
	int	c;

	parsebuf = NULL;
	pushback_index = 0;

	/* skip to either EOF or the first real EOL */
	while (1) {
		c = lgetc(0);
		if (c == '\n') {
			file->lineno++;
			break;
		}
		if (c == EOF)
			break;
	}
	return (ERROR);
}

int
yylex(void)
{
	unsigned char	 buf[8096];
	unsigned char	*p, *val;
	int		 quotec, next, c;
	int		 token;

top:
	p = buf;
	while ((c = lgetc(0)) == ' ' || c == '\t')
		; /* nothing */

	yylval.lineno = file->lineno;
	if (c == '#')
		while ((c = lgetc(0)) != '\n' && c != EOF)
			; /* nothing */
	if (c == '$' && parsebuf == NULL) {
		while (1) {
			if ((c = lgetc(0)) == EOF)
				return (0);

			if (p + 1 >= buf + sizeof(buf) - 1) {
				yyerror("string too long");
				return (findeol());
			}
			if (isalnum(c) || c == '_') {
				*p++ = c;
				continue;
			}
			*p = '\0';
			lungetc(c);
			break;
		}
		val = symget(buf);
		if (val == NULL) {
			yyerror("macro '%s' not defined", buf);
			return (findeol());
		}
		parsebuf = val;
		parseindex = 0;
		goto top;
	}

	switch (c) {
	case '\'':
	case '"':
		quotec = c;
		while (1) {
			if ((c = lgetc(quotec)) == EOF)
				return (0);
			if (c == '\n') {
				file->lineno++;
				continue;
			} else if (c == '\\') {
				if ((next = lgetc(quotec)) == EOF)
					return (0);
				if (next == quotec || c == ' ' || c == '\t')
					c = next;
				else if (next == '\n') {
					file->lineno++;
					continue;
				} else
					lungetc(next);
			} else if (c == quotec) {
				*p = '\0';
				break;
			} else if (c == '\0') {
				yyerror("syntax error");
				return (findeol());
			}
			if (p + 1 >= buf + sizeof(buf) - 1) {
				yyerror("string too long");
				return (findeol());
			}
			*p++ = c;
		}
		yylval.v.string = strdup(buf);
		if (yylval.v.string == NULL)
			err(1, "yylex: strdup");
		return (STRING);
	}

#define allowed_to_end_number(x) \
	(isspace(x) || x == ')' || x ==',' || x == '/' || x == '}' || x == '=')

	if (c == '-' || isdigit(c)) {
		do {
			*p++ = c;
			if ((unsigned)(p-buf) >= sizeof(buf)) {
				yyerror("string too long");
				return (findeol());
			}
		} while ((c = lgetc(0)) != EOF && isdigit(c));
		lungetc(c);
		if (p == buf + 1 && buf[0] == '-')
			goto nodigits;
		if (c == EOF || allowed_to_end_number(c)) {
			const char *errstr = NULL;

			*p = '\0';
			yylval.v.number = strtonum(buf, LLONG_MIN,
			    LLONG_MAX, &errstr);
			if (errstr) {
				yyerror("\"%s\" invalid number: %s",
				    buf, errstr);
				return (findeol());
			}
			return (NUMBER);
		} else {
nodigits:
			while (p > buf + 1)
				lungetc(*--p);
			c = *--p;
			if (c == '-')
				return (c);
		}
	}

	if (c == '=') {
		if ((c = lgetc(0)) != EOF && c == '>')
			return (ARROW);
		lungetc(c);
		c = '=';
	}

#define allowed_in_string(x) \
	(isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \
	x != '{' && x != '}' && x != '<' && x != '>' && \
	x != '!' && x != '=' && x != '#' && \
	x != ','))

	if (isalnum(c) || c == ':' || c == '_') {
		do {
			*p++ = c;
			if ((unsigned)(p-buf) >= sizeof(buf)) {
				yyerror("string too long");
				return (findeol());
			}
		} while ((c = lgetc(0)) != EOF && (allowed_in_string(c)));
		lungetc(c);
		*p = '\0';
		if ((token = lookup(buf)) == STRING)
			if ((yylval.v.string = strdup(buf)) == NULL)
				err(1, "yylex: strdup");
		return (token);
	}
	if (c == '\n') {
		yylval.lineno = file->lineno;
		file->lineno++;
	}
	if (c == EOF)
		return (0);
	return (c);
}

int
check_file_secrecy(int fd, const char *fname)
{
	struct stat	st;

	if (fstat(fd, &st)) {
		log_warn("warn: cannot stat %s", fname);
		return (-1);
	}
	if (st.st_uid != 0 && st.st_uid != getuid()) {
		log_warnx("warn: %s: owner not root or current user", fname);
		return (-1);
	}
	if (st.st_mode & (S_IWGRP | S_IXGRP | S_IRWXO)) {
		log_warnx("warn: %s: group/world readable/writeable", fname);
		return (-1);
	}
	return (0);
}

struct file *
pushfile(const char *name, int secret)
{
	struct file	*nfile;

	if ((nfile = calloc(1, sizeof(struct file))) == NULL) {
		log_warn("warn: malloc");
		return (NULL);
	}
	if ((nfile->name = strdup(name)) == NULL) {
		log_warn("warn: malloc");
		free(nfile);
		return (NULL);
	}
	if ((nfile->stream = fopen(nfile->name, "r")) == NULL) {
		log_warn("warn: %s", nfile->name);
		free(nfile->name);
		free(nfile);
		return (NULL);
	} else if (secret &&
	    check_file_secrecy(fileno(nfile->stream), nfile->name)) {
		fclose(nfile->stream);
		free(nfile->name);
		free(nfile);
		return (NULL);
	}
	nfile->lineno = 1;
	TAILQ_INSERT_TAIL(&files, nfile, entry);
	return (nfile);
}

int
popfile(void)
{
	struct file	*prev;

	if ((prev = TAILQ_PREV(file, files, entry)) != NULL)
		prev->errors += file->errors;

	TAILQ_REMOVE(&files, file, entry);
	fclose(file->stream);
	free(file->name);
	free(file);
	file = prev;
	return (file ? 0 : EOF);
}

int
parse_config(struct smtpd *x_conf, const char *filename, int opts)
{
	struct sym     *sym, *next;
	struct table   *t;
	char		hostname[HOST_NAME_MAX+1];
	char		hostname_copy[HOST_NAME_MAX+1];

	if (getmailname(hostname, sizeof hostname) == -1)
		return (-1);

	conf = x_conf;
	memset(conf, 0, sizeof(*conf));

	(void)strlcpy(conf->sc_hostname, hostname, sizeof(conf->sc_hostname));

	conf->sc_maxsize = DEFAULT_MAX_BODY_SIZE;
	conf->sc_subaddressing_delim = SUBADDRESSING_DELIMITER;

	conf->sc_tables_dict = calloc(1, sizeof(*conf->sc_tables_dict));
	conf->sc_rules = calloc(1, sizeof(*conf->sc_rules));
	conf->sc_listeners = calloc(1, sizeof(*conf->sc_listeners));
	conf->sc_ca_dict = calloc(1, sizeof(*conf->sc_ca_dict));
	conf->sc_pki_dict = calloc(1, sizeof(*conf->sc_pki_dict));
	conf->sc_ssl_dict = calloc(1, sizeof(*conf->sc_ssl_dict));
	conf->sc_limits_dict = calloc(1, sizeof(*conf->sc_limits_dict));

	/* Report mails delayed for more than 4 hours */
	conf->sc_bounce_warn[0] = 3600 * 4;

	if (conf->sc_tables_dict == NULL	||
	    conf->sc_rules == NULL		||
	    conf->sc_listeners == NULL		||
	    conf->sc_ca_dict == NULL		||
	    conf->sc_pki_dict == NULL		||
	    conf->sc_ssl_dict == NULL		||
	    conf->sc_limits_dict == NULL) {
		log_warn("warn: cannot allocate memory");
		free(conf->sc_tables_dict);
		free(conf->sc_rules);
		free(conf->sc_listeners);
		free(conf->sc_ca_dict);
		free(conf->sc_pki_dict);
		free(conf->sc_ssl_dict);
		free(conf->sc_limits_dict);
		return (-1);
	}

	errors = 0;

	table = NULL;
	rule = NULL;

	dict_init(conf->sc_ca_dict);
	dict_init(conf->sc_pki_dict);
	dict_init(conf->sc_ssl_dict);
	dict_init(conf->sc_tables_dict);

	dict_init(conf->sc_limits_dict);
	limits = xcalloc(1, sizeof(*limits), "mta_limits");
	limit_mta_set_defaults(limits);
	dict_xset(conf->sc_limits_dict, "default", limits);

	TAILQ_INIT(conf->sc_listeners);
	TAILQ_INIT(conf->sc_rules);

	conf->sc_qexpire = SMTPD_QUEUE_EXPIRY;
	conf->sc_opts = opts;

	conf->sc_mta_max_deferred = 100;
	conf->sc_scheduler_max_inflight = 5000;
	conf->sc_scheduler_max_schedule = 10;
	conf->sc_scheduler_max_evp_batch_size = 256;
	conf->sc_scheduler_max_msg_batch_size = 1024;

	conf->sc_session_max_rcpt = 1000;
	conf->sc_session_max_mails = 100;

	conf->sc_mda_max_session = 50;
	conf->sc_mda_max_user_session = 7;
	conf->sc_mda_task_hiwat = 50;
	conf->sc_mda_task_lowat = 30;
	conf->sc_mda_task_release = 10;

	if ((file = pushfile(filename, 0)) == NULL) {
		purge_config(PURGE_EVERYTHING);
		return (-1);
	}
	topfile = file;

	/*
	 * declare special "localhost", "anyhost" and "localnames" tables
	 */
	set_local(hostname);

	t = table_create("static", "<anydestination>", NULL, NULL);
	t->t_type = T_LIST;
	table_add(t, "*", NULL);

	/* can't truncate here */
	(void)strlcpy(hostname_copy, hostname, sizeof hostname_copy);

	hostname_copy[strcspn(hostname_copy, ".")] = '\0';
	if (strcmp(hostname, hostname_copy) != 0)
		table_add(t, hostname_copy, NULL);

	table_create("getpwnam", "<getpwnam>", NULL, NULL);

	/*
	 * parse configuration
	 */
	setservent(1);
	yyparse();
	errors = file->errors;
	popfile();
	endservent();

	/* If the socket listener was not configured, create a default one. */
	if (!conf->sc_sock_listener) {
		memset(&listen_opts, 0, sizeof listen_opts);
		create_sock_listener(&listen_opts);
	}

	/* Free macros and check which have not been used. */
	TAILQ_FOREACH_SAFE(sym, &symhead, entry, next) {
		if ((conf->sc_opts & SMTPD_OPT_VERBOSE) && !sym->used)
			fprintf(stderr, "warning: macro '%s' not "
			    "used\n", sym->nam);
		if (!sym->persist) {
			free(sym->nam);
			free(sym->val);
			TAILQ_REMOVE(&symhead, sym, entry);
			free(sym);
		}
	}

	if (TAILQ_EMPTY(conf->sc_rules)) {
		log_warnx("warn: no rules, nothing to do");
		errors++;
	}

	if (errors) {
		purge_config(PURGE_EVERYTHING);
		return (-1);
	}

	return (0);
}

int
symset(const char *nam, const char *val, int persist)
{
	struct sym	*sym;

	TAILQ_FOREACH(sym, &symhead, entry) {
		if (strcmp(nam, sym->nam) == 0)
			break;
	}

	if (sym != NULL) {
		if (sym->persist == 1)
			return (0);
		else {
			free(sym->nam);
			free(sym->val);
			TAILQ_REMOVE(&symhead, sym, entry);
			free(sym);
		}
	}
	if ((sym = calloc(1, sizeof(*sym))) == NULL)
		return (-1);

	sym->nam = strdup(nam);
	if (sym->nam == NULL) {
		free(sym);
		return (-1);
	}
	sym->val = strdup(val);
	if (sym->val == NULL) {
		free(sym->nam);
		free(sym);
		return (-1);
	}
	sym->used = 0;
	sym->persist = persist;
	TAILQ_INSERT_TAIL(&symhead, sym, entry);
	return (0);
}

int
cmdline_symset(char *s)
{
	char	*sym, *val;
	int	ret;
	size_t	len;

	if ((val = strrchr(s, '=')) == NULL)
		return (-1);

	len = strlen(s) - strlen(val) + 1;
	if ((sym = malloc(len)) == NULL)
		errx(1, "cmdline_symset: malloc");

	(void)strlcpy(sym, s, len);

	ret = symset(sym, val + 1, 1);
	free(sym);

	return (ret);
}

char *
symget(const char *nam)
{
	struct sym	*sym;

	TAILQ_FOREACH(sym, &symhead, entry) {
		if (strcmp(nam, sym->nam) == 0) {
			sym->used = 1;
			return (sym->val);
		}
	}
	return (NULL);
}

static void
create_sock_listener(struct listen_opts *lo)
{
	struct listener *l = xcalloc(1, sizeof(*l), "create_sock_listener");
	lo->tag = "local";
	lo->hostname = conf->sc_hostname;
	l->ss.ss_family = AF_LOCAL;
	l->ss.ss_len = sizeof(struct sockaddr *);
	l->local = 1;
	conf->sc_sock_listener = l;
	config_listener(l, lo);
}

static void
create_if_listener(struct listen_opts *lo)
{
	uint16_t	flags;

	if (lo->port != 0 && lo->ssl == F_SSL)
		errx(1, "invalid listen option: tls/smtps on same port");

	if (lo->auth != 0 && !lo->ssl)
		errx(1, "invalid listen option: auth requires tls/smtps");

	if (lo->pki && !lo->ssl)
		errx(1, "invalid listen option: pki requires tls/smtps");

	flags = lo->flags;

	if (lo->port) {
		lo->flags = lo->ssl|lo->auth|flags;
		lo->port = htons(lo->port);
	}
	else {
		if (lo->ssl & F_SMTPS) {
			lo->port = htons(465);
			lo->flags = F_SMTPS|lo->auth|flags;
		}

		if (!lo->ssl || (lo->ssl & F_STARTTLS)) {
			lo->port = htons(25);
			lo->flags = lo->auth|flags;
			if (lo->ssl & F_STARTTLS)
				lo->flags |= F_STARTTLS;
		}
	}

	if (interface(lo))
		return;
	if (host_v4(lo))
		return;
	if (host_v6(lo))
		return;
	if (host_dns(lo))
		return;

	errx(1, "invalid virtual ip or interface: %s", lo->ifx);
}

static void
config_listener(struct listener *h,  struct listen_opts *lo)
{
	h->fd = -1;
	h->port = lo->port;
	h->flags = lo->flags;

	if (lo->hostname == NULL)
		lo->hostname = conf->sc_hostname;

	if (lo->filtername)
		(void)strlcpy(h->filter, lo->filtername, sizeof(h->filter));

	h->pki_name[0] = '\0';

	if (lo->authtable != NULL)
		(void)strlcpy(h->authtable, lo->authtable->t_name, sizeof(h->authtable));
	if (lo->pki != NULL) {
		if (!lowercase(h->pki_name, lo->pki, sizeof(h->pki_name))) {
			log_warnx("pki name too long: %s", lo->pki);
			fatalx(NULL);
		}
		if (dict_get(conf->sc_pki_dict, h->pki_name) == NULL) {
			log_warnx("pki name not found: %s", lo->pki);
			fatalx(NULL);
		}
	}

	if (lo->ca != NULL) {
		if (!lowercase(h->ca_name, lo->ca, sizeof(h->ca_name))) {
			log_warnx("ca name too long: %s", lo->ca);
			fatalx(NULL);
		}
		if (dict_get(conf->sc_ca_dict, h->ca_name) == NULL) {
			log_warnx("ca name not found: %s", lo->ca);
			fatalx(NULL);
		}
	}
	if (lo->tag != NULL)
		(void)strlcpy(h->tag, lo->tag, sizeof(h->tag));

	(void)strlcpy(h->hostname, lo->hostname, sizeof(h->hostname));
	if (lo->hostnametable)
		(void)strlcpy(h->hostnametable, lo->hostnametable->t_name, sizeof(h->hostnametable));
	if (lo->sendertable) {
		(void)strlcpy(h->sendertable, lo->sendertable->t_name, sizeof(h->sendertable));
		if (lo->options & LO_MASQUERADE)
			h->flags |= F_MASQUERADE;
	}

	if (lo->ssl & F_TLS_VERIFY)
		h->flags |= F_TLS_VERIFY;

	if (lo->ssl & F_STARTTLS_REQUIRE)
		h->flags |= F_STARTTLS_REQUIRE;

	if (h != conf->sc_sock_listener)
		TAILQ_INSERT_TAIL(conf->sc_listeners, h, entry);
}

static int
host_v4(struct listen_opts *lo)
{
	struct in_addr		 ina;
	struct sockaddr_in	*sain;
	struct listener		*h;

	if (lo->family != AF_UNSPEC && lo->family != AF_INET)
		return (0);

	memset(&ina, 0, sizeof(ina));
	if (inet_pton(AF_INET, lo->ifx, &ina) != 1)
		return (0);

	h = xcalloc(1, sizeof(*h), "host_v4");
	sain = (struct sockaddr_in *)&h->ss;
	sain->sin_len = sizeof(struct sockaddr_in);
	sain->sin_family = AF_INET;
	sain->sin_addr.s_addr = ina.s_addr;
	sain->sin_port = lo->port;

	if (sain->sin_addr.s_addr == htonl(INADDR_LOOPBACK))
		h->local = 1;
	config_listener(h,  lo);

	return (1);
}

static int
host_v6(struct listen_opts *lo)
{
	struct in6_addr		 ina6;
	struct sockaddr_in6	*sin6;
	struct listener		*h;

	if (lo->family != AF_UNSPEC && lo->family != AF_INET6)
		return (0);

	memset(&ina6, 0, sizeof(ina6));
	if (inet_pton(AF_INET6, lo->ifx, &ina6) != 1)
		return (0);

	h = xcalloc(1, sizeof(*h), "host_v6");
	sin6 = (struct sockaddr_in6 *)&h->ss;
	sin6->sin6_len = sizeof(struct sockaddr_in6);
	sin6->sin6_family = AF_INET6;
	sin6->sin6_port = lo->port;
	memcpy(&sin6->sin6_addr, &ina6, sizeof(ina6));

	if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
		h->local = 1;
	config_listener(h,  lo);

	return (1);
}

static int
host_dns(struct listen_opts *lo)
{
	struct addrinfo		 hints, *res0, *res;
	int			 error, cnt = 0;
	struct sockaddr_in	*sain;
	struct sockaddr_in6	*sin6;
	struct listener		*h;

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = lo->family;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_ADDRCONFIG;
	error = getaddrinfo(lo->ifx, NULL, &hints, &res0);
	if (error == EAI_AGAIN || error == EAI_NODATA || error == EAI_NONAME)
		return (0);
	if (error) {
		log_warnx("warn: host_dns: could not parse \"%s\": %s", lo->ifx,
		    gai_strerror(error));
		return (-1);
	}

	for (res = res0; res; res = res->ai_next) {
		if (res->ai_family != AF_INET &&
		    res->ai_family != AF_INET6)
			continue;
		h = xcalloc(1, sizeof(*h), "host_dns");

		h->ss.ss_family = res->ai_family;
		if (res->ai_family == AF_INET) {
			sain = (struct sockaddr_in *)&h->ss;
			sain->sin_len = sizeof(struct sockaddr_in);
			sain->sin_addr.s_addr = ((struct sockaddr_in *)
			    res->ai_addr)->sin_addr.s_addr;
			sain->sin_port = lo->port;
			if (sain->sin_addr.s_addr == htonl(INADDR_LOOPBACK))
				h->local = 1;
		} else {
			sin6 = (struct sockaddr_in6 *)&h->ss;
			sin6->sin6_len = sizeof(struct sockaddr_in6);
			memcpy(&sin6->sin6_addr, &((struct sockaddr_in6 *)
			    res->ai_addr)->sin6_addr, sizeof(struct in6_addr));
			sin6->sin6_port = lo->port;
			if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
				h->local = 1;
		}

		config_listener(h, lo);

		cnt++;
	}

	freeaddrinfo(res0);
	return (cnt);
}

static int
interface(struct listen_opts *lo)
{
	struct ifaddrs *ifap, *p;
	struct sockaddr_in	*sain;
	struct sockaddr_in6	*sin6;
	struct listener		*h;
	int			ret = 0;

	if (getifaddrs(&ifap) == -1)
		fatal("getifaddrs");

	for (p = ifap; p != NULL; p = p->ifa_next) {
		if (p->ifa_addr == NULL)
			continue;
		if (strcmp(p->ifa_name, lo->ifx) != 0 &&
		    !is_if_in_group(p->ifa_name, lo->ifx))
			continue;
		if (lo->family != AF_UNSPEC && lo->family != p->ifa_addr->sa_family)
			continue;

		h = xcalloc(1, sizeof(*h), "interface");

		switch (p->ifa_addr->sa_family) {
		case AF_INET:
			sain = (struct sockaddr_in *)&h->ss;
			*sain = *(struct sockaddr_in *)p->ifa_addr;
			sain->sin_len = sizeof(struct sockaddr_in);
			sain->sin_port = lo->port;
			if (sain->sin_addr.s_addr == htonl(INADDR_LOOPBACK))
				h->local = 1;
			break;

		case AF_INET6:
			sin6 = (struct sockaddr_in6 *)&h->ss;
			*sin6 = *(struct sockaddr_in6 *)p->ifa_addr;
			sin6->sin6_len = sizeof(struct sockaddr_in6);
			sin6->sin6_port = lo->port;
			if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
				h->local = 1;
			break;

		default:
			free(h);
			continue;
		}

		config_listener(h, lo);
		ret = 1;
	}

	freeifaddrs(ifap);

	return ret;
}

void
set_local(const char *hostname)
{
	struct table	*t;

	t = table_create("static", "<localnames>", NULL, NULL);
	t->t_type = T_LIST;
	table_add(t, "localhost", NULL);
	table_add(t, hostname, NULL);

	set_localaddrs(t);
}

void
set_localaddrs(struct table *localnames)
{
	struct ifaddrs *ifap, *p;
	struct sockaddr_storage ss;
	struct sockaddr_in	*sain;
	struct sockaddr_in6	*sin6;
	struct table		*t;
	char buf[NI_MAXHOST + 5];

	t = table_create("static", "<anyhost>", NULL, NULL);
	table_add(t, "local", NULL);
	table_add(t, "0.0.0.0/0", NULL);
	table_add(t, "::/0", NULL);

	if (getifaddrs(&ifap) == -1)
		fatal("getifaddrs");

	t = table_create("static", "<localhost>", NULL, NULL);
	table_add(t, "local", NULL);

	for (p = ifap; p != NULL; p = p->ifa_next) {
		if (p->ifa_addr == NULL)
			continue;
		switch (p->ifa_addr->sa_family) {
		case AF_INET:
			sain = (struct sockaddr_in *)&ss;
			*sain = *(struct sockaddr_in *)p->ifa_addr;
			sain->sin_len = sizeof(struct sockaddr_in);
			table_add(t, ss_to_text(&ss), NULL);
			table_add(localnames, ss_to_text(&ss), NULL);
			(void)snprintf(buf, sizeof buf, "[%s]", ss_to_text(&ss));
			table_add(localnames, buf, NULL);
			break;

		case AF_INET6:
			sin6 = (struct sockaddr_in6 *)&ss;
			*sin6 = *(struct sockaddr_in6 *)p->ifa_addr;
			sin6->sin6_len = sizeof(struct sockaddr_in6);
			table_add(t, ss_to_text(&ss), NULL);
			table_add(localnames, ss_to_text(&ss), NULL);
			(void)snprintf(buf, sizeof buf, "[%s]", ss_to_text(&ss));
			table_add(localnames, buf, NULL);
			(void)snprintf(buf, sizeof buf, "[ipv6:%s]", ss_to_text(&ss));
			table_add(localnames, buf, NULL);
			break;
		}
	}

	freeifaddrs(ifap);
}

int
delaytonum(char *str)
{
	unsigned int     factor;
	size_t           len;
	const char      *errstr = NULL;
	int              delay;

	/* we need at least 1 digit and 1 unit */
	len = strlen(str);
	if (len < 2)
		goto bad;

	switch(str[len - 1]) {

	case 's':
		factor = 1;
		break;

	case 'm':
		factor = 60;
		break;

	case 'h':
		factor = 60 * 60;
		break;

	case 'd':
		factor = 24 * 60 * 60;
		break;

	default:
		goto bad;
	}

	str[len - 1] = '\0';
	delay = strtonum(str, 1, INT_MAX / factor, &errstr);
	if (errstr)
		goto bad;

	return (delay * factor);

bad:
	return (-1);
}

int
is_if_in_group(const char *ifname, const char *groupname)
{
        unsigned int		 len;
        struct ifgroupreq        ifgr;
        struct ifg_req          *ifg;
	int			 s;
	int			 ret = 0;

	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
		err(1, "socket");

        memset(&ifgr, 0, sizeof(ifgr));
        if (strlcpy(ifgr.ifgr_name, ifname, IFNAMSIZ) >= IFNAMSIZ)
		errx(1, "interface name too large");

        if (ioctl(s, SIOCGIFGROUP, (caddr_t)&ifgr) == -1) {
                if (errno == EINVAL || errno == ENOTTY)
			goto end;
		err(1, "SIOCGIFGROUP");
        }

        len = ifgr.ifgr_len;
        ifgr.ifgr_groups = xcalloc(len/sizeof(struct ifg_req),
		sizeof(struct ifg_req), "is_if_in_group");
        if (ioctl(s, SIOCGIFGROUP, (caddr_t)&ifgr) == -1)
                err(1, "SIOCGIFGROUP");

        ifg = ifgr.ifgr_groups;
        for (; ifg && len >= sizeof(struct ifg_req); ifg++) {
                len -= sizeof(struct ifg_req);
		if (strcmp(ifg->ifgrq_group, groupname) == 0) {
			ret = 1;
			break;
		}
        }
        free(ifgr.ifgr_groups);

end:
	close(s);
	return ret;
}

static int
config_lo_filter(struct listen_opts *lo, char *filter_name) {
	if (lo->options & LO_FILTER) {
		yyerror("filter already specified");
		return -1;
	}
	lo->options |= LO_FILTER;
	lo->filtername = filter_name;

	return 0;
}

static int
config_lo_mask_source(struct listen_opts *lo) {
	if (lo->options & LO_MASKSOURCE) {
		yyerror("mask-source already specified");
		return -1;
	}
	lo->options |= LO_MASKSOURCE;
	lo->flags |= F_MASK_SOURCE;

	return 0;
}

#line 1876 "parse.c"
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(void)
{
    unsigned int newsize;
    long sslen;
    short *newss;
    YYSTYPE *newvs;

    if ((newsize = yystacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return -1;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;
    sslen = yyssp - yyss;
#ifdef SIZE_MAX
#define YY_SIZE_MAX SIZE_MAX
#else
#define YY_SIZE_MAX 0xffffffffU
#endif
    if (newsize && YY_SIZE_MAX / newsize < sizeof *newss)
        goto bail;
    newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
      (short *)malloc(newsize * sizeof *newss); /* overflow check above */
    if (newss == NULL)
        goto bail;
    yyss = newss;
    yyssp = newss + sslen;
    if (newsize && YY_SIZE_MAX / newsize < sizeof *newvs)
        goto bail;
    newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
      (YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */
    if (newvs == NULL)
        goto bail;
    yyvs = newvs;
    yyvsp = newvs + sslen;
    yystacksize = newsize;
    yysslim = yyss + newsize - 1;
    return 0;
bail:
    if (yyss)
            free(yyss);
    if (yyvs)
            free(yyvs);
    yyss = yyssp = NULL;
    yyvs = yyvsp = NULL;
    yystacksize = 0;
    return -1;
}

#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
int
yyparse(void)
{
    int yym, yyn, yystate;
#if YYDEBUG
    const char *yys;

    if ((yys = getenv("YYDEBUG")))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif /* YYDEBUG */

    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);

    if (yyss == NULL && yygrowstack()) goto yyoverflow;
    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;

yyloop:
    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yyssp >= yysslim && yygrowstack())
        {
            goto yyoverflow;
        }
        *++yyssp = yystate = yytable[yyn];
        *++yyvsp = yylval;
        yychar = (-1);
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;
#if defined(__GNUC__)
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#if defined(__GNUC__)
    goto yyerrlab;
#endif
yyerrlab:
    ++yynerrs;
yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
                if (yyssp >= yysslim && yygrowstack())
                {
                    goto yyoverflow;
                }
                *++yyssp = yystate = yytable[yyn];
                *++yyvsp = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *yyssp);
#endif
                if (yyssp <= yyss) goto yyabort;
                --yyssp;
                --yyvsp;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = (-1);
        goto yyloop;
    }
yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    if (yym)
        yyval = yyvsp[1-yym];
    else
        memset(&yyval, 0, sizeof yyval);
    switch (yyn)
    {
case 8:
#line 193 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{ file->errors++; }
break;
case 9:
#line 196 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct file	*nfile;

			if ((nfile = pushfile(yyvsp[0].v.string, 0)) == NULL) {
				yyerror("failed to include file %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);

			file = nfile;
			lungetc('\n');
		}
break;
case 10:
#line 211 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			char *s = yyvsp[-2].v.string;
			while (*s++) {
				if (isspace((unsigned char)*s)) {
					yyerror("macro name cannot contain "
					    "whitespace");
					YYERROR;
				}
			}
			if (symset(yyvsp[-2].v.string, yyvsp[0].v.string, 0) == -1)
				fatal("cannot store variable");
			free(yyvsp[-2].v.string);
			free(yyvsp[0].v.string);
		}
break;
case 17:
#line 239 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (yyvsp[0].v.number < 0) {
				yyerror("invalid size: %" PRId64, yyvsp[0].v.number);
				YYERROR;
			}
			yyval.v.number = yyvsp[0].v.number;
		}
break;
case 18:
#line 246 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			long long result;

			if (scan_scaled(yyvsp[0].v.string, &result) == -1 || result < 0) {
				yyerror("invalid size: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			yyval.v.number = result;
		}
break;
case 19:
#line 259 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (strlcpy(rule->r_tag, yyvsp[0].v.string, sizeof rule->r_tag)
			    >= sizeof rule->r_tag) {
				yyerror("tag name too long: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			rule->r_nottag = yyvsp[-1].v.number;
		}
break;
case 20:
#line 271 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_wantauth = 1;
			rule->r_negwantauth = yyvsp[-1].v.number;
		}
break;
case 21:
#line 277 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			time_t	d;
			int	i;

			d = delaytonum(yyvsp[0].v.string);
			if (d < 0) {
				yyerror("invalid bounce delay: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			for (i = 0; i < MAX_BOUNCE_WARN; i++) {
				if (conf->sc_bounce_warn[i] != 0)
					continue;
				conf->sc_bounce_warn[i] = d;
				break;
			}
		}
break;
case 25:
#line 301 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (!strcmp(yyvsp[-1].v.string, "max-session")) {
				conf->sc_mda_max_session = yyvsp[0].v.number;
			}
			else if (!strcmp(yyvsp[-1].v.string, "max-session-per-user")) {
				conf->sc_mda_max_user_session = yyvsp[0].v.number;
			}
			else if (!strcmp(yyvsp[-1].v.string, "task-lowat")) {
				conf->sc_mda_task_lowat = yyvsp[0].v.number;
			}
			else if (!strcmp(yyvsp[-1].v.string, "task-hiwat")) {
				conf->sc_mda_task_hiwat = yyvsp[0].v.number;
			}
			else if (!strcmp(yyvsp[-1].v.string, "task-release")) {
				conf->sc_mda_task_release = yyvsp[0].v.number;
			}
			else {
				yyerror("invalid scheduler limit keyword: %s", yyvsp[-1].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-1].v.string);
		}
break;
case 28:
#line 330 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (!strcmp(yyvsp[-1].v.string, "max-rcpt")) {
				conf->sc_session_max_rcpt = yyvsp[0].v.number;
			}
			else if (!strcmp(yyvsp[-1].v.string, "max-mails")) {
				conf->sc_session_max_mails = yyvsp[0].v.number;
			}
			else {
				yyerror("invalid session limit keyword: %s", yyvsp[-1].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-1].v.string);
		}
break;
case 31:
#line 350 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			limits->family = AF_INET;
		}
break;
case 32:
#line 353 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			limits->family = AF_INET6;
		}
break;
case 33:
#line 356 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (!limit_mta_set(limits, yyvsp[-1].v.string, yyvsp[0].v.number)) {
				yyerror("invalid mta limit keyword: %s", yyvsp[-1].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-1].v.string);
		}
break;
case 36:
#line 370 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (!strcmp(yyvsp[-1].v.string, "max-inflight")) {
				conf->sc_scheduler_max_inflight = yyvsp[0].v.number;
			}
			else if (!strcmp(yyvsp[-1].v.string, "max-evp-batch-size")) {
				conf->sc_scheduler_max_evp_batch_size = yyvsp[0].v.number;
			}
			else if (!strcmp(yyvsp[-1].v.string, "max-msg-batch-size")) {
				conf->sc_scheduler_max_msg_batch_size = yyvsp[0].v.number;
			}
			else if (!strcmp(yyvsp[-1].v.string, "max-schedule")) {
				conf->sc_scheduler_max_schedule = yyvsp[0].v.number;
			}
			else {
				yyerror("invalid scheduler limit keyword: %s", yyvsp[-1].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-1].v.string);
		}
break;
case 39:
#line 396 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			sca->ca_cert_file = yyvsp[0].v.string;
		}
break;
case 41:
#line 404 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			pki->pki_cert_file = yyvsp[0].v.string;
		}
break;
case 42:
#line 407 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			pki->pki_key_file = yyvsp[0].v.string;
		}
break;
case 43:
#line 410 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (strcasecmp(yyvsp[0].v.string, "none") == 0)
				pki->pki_dhe = 0;
			else if (strcasecmp(yyvsp[0].v.string, "auto") == 0)
				pki->pki_dhe = 1;
			else if (strcasecmp(yyvsp[0].v.string, "legacy") == 0)
				pki->pki_dhe = 2;
			else {
				yyerror("invalid DHE keyword: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 46:
#line 430 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (config_lo_filter(&listen_opts, yyvsp[0].v.string)) {
				YYERROR;
			}
		}
break;
case 47:
#line 435 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (config_lo_mask_source(&listen_opts)) {
				YYERROR;
			}
		}
break;
case 48:
#line 442 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_FAMILY) {
				yyerror("address family already specified");
				YYERROR;
			}
			listen_opts.options |= LO_FAMILY;
			listen_opts.family = AF_INET;
		}
break;
case 49:
#line 450 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_FAMILY) {
				yyerror("address family already specified");
				YYERROR;
			}
			listen_opts.options |= LO_FAMILY;
			listen_opts.family = AF_INET6;
		}
break;
case 50:
#line 458 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct servent	*servent;

			if (listen_opts.options & LO_PORT) {
				yyerror("port already specified");
				YYERROR;
			}
			listen_opts.options |= LO_PORT;

			servent = getservbyname(yyvsp[0].v.string, "tcp");
			if (servent == NULL) {
				yyerror("invalid port: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
			listen_opts.port = ntohs(servent->s_port);
		}
break;
case 51:
#line 476 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_PORT) {
				yyerror("port already specified");
				YYERROR;
			}
			listen_opts.options |= LO_PORT;

			if (yyvsp[0].v.number <= 0 || yyvsp[0].v.number > (int)USHRT_MAX) {
				yyerror("invalid port: %" PRId64, yyvsp[0].v.number);
				YYERROR;
			}
			listen_opts.port = yyvsp[0].v.number;
		}
break;
case 52:
#line 489 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (config_lo_filter(&listen_opts, yyvsp[0].v.string)) {
				YYERROR;
			}
		}
break;
case 53:
#line 494 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_SSL) {
				yyerror("TLS mode already specified");
				YYERROR;
			}
			listen_opts.options |= LO_SSL;
			listen_opts.ssl = F_SMTPS;
		}
break;
case 54:
#line 502 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_SSL) {
				yyerror("TLS mode already specified");
				YYERROR;
			}
			listen_opts.options |= LO_SSL;
			listen_opts.ssl = F_SMTPS|F_TLS_VERIFY;
		}
break;
case 55:
#line 510 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_SSL) {
				yyerror("TLS mode already specified");
				YYERROR;
			}
			listen_opts.options |= LO_SSL;
			listen_opts.ssl = F_STARTTLS;
		}
break;
case 56:
#line 518 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_SSL) {
				yyerror("TLS mode already specified");
				YYERROR;
			}
			listen_opts.options |= LO_SSL;
			listen_opts.ssl = F_STARTTLS|F_STARTTLS_REQUIRE;
		}
break;
case 57:
#line 526 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_SSL) {
				yyerror("TLS mode already specified");
				YYERROR;
			}
			listen_opts.options |= LO_SSL;
			listen_opts.ssl = F_STARTTLS|F_STARTTLS_REQUIRE|F_TLS_VERIFY;
		}
break;
case 58:
#line 534 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_PKI) {
				yyerror("pki already specified");
				YYERROR;
			}
			listen_opts.options |= LO_PKI;
			listen_opts.pki = yyvsp[0].v.string;
		}
break;
case 59:
#line 542 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_CA) {
				yyerror("ca already specified");
				YYERROR;
			}
			listen_opts.options |= LO_CA;
			listen_opts.ca = yyvsp[0].v.string;
		}
break;
case 60:
#line 550 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_AUTH) {
				yyerror("auth already specified");
				YYERROR;
			}
			listen_opts.options |= LO_AUTH;
			listen_opts.auth = F_AUTH|F_AUTH_REQUIRE;
		}
break;
case 61:
#line 558 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_AUTH) {
				yyerror("auth already specified");
				YYERROR;
			}
			listen_opts.options |= LO_AUTH;
			listen_opts.auth = F_AUTH;
		}
break;
case 62:
#line 566 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_AUTH) {
				yyerror("auth already specified");
				YYERROR;
			}
			listen_opts.options |= LO_AUTH;
			listen_opts.authtable = yyvsp[0].v.table;
			listen_opts.auth = F_AUTH|F_AUTH_REQUIRE;
		}
break;
case 63:
#line 575 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_AUTH) {
				yyerror("auth already specified");
				YYERROR;
			}
			listen_opts.options |= LO_AUTH;
			listen_opts.authtable = yyvsp[0].v.table;
			listen_opts.auth = F_AUTH;
		}
break;
case 64:
#line 584 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_TAG) {
				yyerror("tag already specified");
				YYERROR;
			}
			listen_opts.options |= LO_TAG;

			if (strlen(yyvsp[0].v.string) >= SMTPD_TAG_SIZE) {
       				yyerror("tag name too long");
				free(yyvsp[0].v.string);
				YYERROR;
			}
			listen_opts.tag = yyvsp[0].v.string;
		}
break;
case 65:
#line 598 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_HOSTNAME) {
				yyerror("hostname already specified");
				YYERROR;
			}
			listen_opts.options |= LO_HOSTNAME;

			listen_opts.hostname = yyvsp[0].v.string;
		}
break;
case 66:
#line 607 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table	*t = yyvsp[0].v.table;

			if (listen_opts.options & LO_HOSTNAMES) {
				yyerror("hostnames already specified");
				YYERROR;
			}
			listen_opts.options |= LO_HOSTNAMES;

			if (!table_check_use(t, T_DYNAMIC|T_HASH, K_ADDRNAME)) {
				yyerror("invalid use of table \"%s\" as "
				    "HOSTNAMES parameter", t->t_name);
				YYERROR;
			}
			listen_opts.hostnametable = t;
		}
break;
case 67:
#line 623 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (config_lo_mask_source(&listen_opts)) {
				YYERROR;
			}
		}
break;
case 68:
#line 628 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_RECEIVEDAUTH) {
				yyerror("received-auth already specified");
				YYERROR;
			}
			listen_opts.options |= LO_RECEIVEDAUTH;
			listen_opts.flags |= F_RECEIVEDAUTH;
		}
break;
case 69:
#line 636 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (listen_opts.options & LO_NODSN) {
				yyerror("no-dsn already specified");
				YYERROR;
			}
			listen_opts.options |= LO_NODSN;
			listen_opts.flags &= ~F_EXT_DSN;
		}
break;
case 70:
#line 644 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table	*t = yyvsp[0].v.table;

			if (listen_opts.options & LO_SENDERS) {
				yyerror("senders already specified");
				YYERROR;
			}
			listen_opts.options |= LO_SENDERS;

			if (!table_check_use(t, T_DYNAMIC|T_HASH, K_MAILADDRMAP)) {
				yyerror("invalid use of table \"%s\" as "
				    "SENDERS parameter", t->t_name);
				YYERROR;
			}
			listen_opts.sendertable = t;
		}
break;
case 71:
#line 660 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table	*t = yyvsp[-1].v.table;

			if (listen_opts.options & LO_SENDERS) {
				yyerror("senders already specified");
				YYERROR;
			}
			listen_opts.options |= LO_SENDERS|LO_MASQUERADE;

			if (!table_check_use(t, T_DYNAMIC|T_HASH, K_MAILADDRMAP)) {
				yyerror("invalid use of table \"%s\" as "
				    "SENDERS parameter", t->t_name);
				YYERROR;
			}
			listen_opts.sendertable = t;
		}
break;
case 74:
#line 682 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (conf->sc_sock_listener) {
				yyerror("socket listener already configured");
				YYERROR;
			}
			create_sock_listener(&listen_opts);
		}
break;
case 75:
#line 691 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			listen_opts.ifx = yyvsp[-1].v.string;
			create_if_listener(&listen_opts);
		}
break;
case 80:
#line 705 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct mailaddr maddr, *maddrp;

			if (!text_to_mailaddr(&maddr, yyvsp[0].v.string)) {
				yyerror("invalid parameter to AS: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);

			if (maddr.user[0] == '\0' && maddr.domain[0] == '\0') {
				yyerror("invalid empty parameter to AS");
				YYERROR;
			}
			else if (maddr.domain[0] == '\0') {
				if (strlcpy(maddr.domain, conf->sc_hostname,
					sizeof (maddr.domain))
				    >= sizeof (maddr.domain)) {
					yyerror("hostname too long for AS parameter: %s",
					    conf->sc_hostname);
					YYERROR;
				}
			}
			rule->r_as = xmemdup(&maddr, sizeof (*maddrp), "parse relay_as: AS");
		}
break;
case 81:
#line 730 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table	*t = yyvsp[0].v.table;
			if (!table_check_use(t, T_DYNAMIC|T_LIST, K_SOURCE)) {
				yyerror("invalid use of table \"%s\" as "
				    "SOURCE parameter", t->t_name);
				YYERROR;
			}
			(void)strlcpy(rule->r_value.relayhost.sourcetable, t->t_name,
			    sizeof rule->r_value.relayhost.sourcetable);
		}
break;
case 82:
#line 740 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			(void)strlcpy(rule->r_value.relayhost.heloname, yyvsp[0].v.string,
			    sizeof rule->r_value.relayhost.heloname);
			free(yyvsp[0].v.string);
		}
break;
case 83:
#line 745 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table	*t = yyvsp[0].v.table;
			if (!table_check_use(t, T_DYNAMIC|T_HASH, K_ADDRNAME)) {
				yyerror("invalid use of table \"%s\" as "
				    "HOSTNAMES parameter", t->t_name);
				YYERROR;
			}
			(void)strlcpy(rule->r_value.relayhost.helotable, t->t_name,
			    sizeof rule->r_value.relayhost.helotable);
		}
break;
case 84:
#line 755 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (!lowercase(rule->r_value.relayhost.pki_name, yyvsp[0].v.string,
				sizeof(rule->r_value.relayhost.pki_name))) {
				yyerror("pki name too long: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			if (dict_get(conf->sc_pki_dict,
				rule->r_value.relayhost.pki_name) == NULL) {
				log_warnx("pki name not found: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 85:
#line 770 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (!lowercase(rule->r_value.relayhost.ca_name, yyvsp[0].v.string,
				sizeof(rule->r_value.relayhost.ca_name))) {
				yyerror("ca name too long: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			if (dict_get(conf->sc_ca_dict,
				rule->r_value.relayhost.ca_name) == NULL) {
				log_warnx("ca name not found: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 86:
#line 787 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_value.relayhost.flags |= F_BACKUP;
			if (strlcpy(rule->r_value.relayhost.hostname, yyvsp[0].v.string,
				sizeof (rule->r_value.relayhost.hostname))
			    >= sizeof (rule->r_value.relayhost.hostname)) {
				log_warnx("hostname too long: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 87:
#line 798 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_value.relayhost.flags |= F_BACKUP;
			(void)strlcpy(rule->r_value.relayhost.hostname,
			    conf->sc_hostname,
			    sizeof (rule->r_value.relayhost.hostname));
		}
break;
case 88:
#line 804 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_value.relayhost.flags |= F_STARTTLS;
		}
break;
case 89:
#line 807 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_value.relayhost.flags |= F_STARTTLS|F_TLS_VERIFY;
		}
break;
case 93:
#line 817 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table   *t = yyvsp[0].v.table;

			if (!table_check_use(t, T_DYNAMIC|T_HASH, K_CREDENTIALS)) {
				yyerror("invalid use of table \"%s\" as AUTH parameter",
				    t->t_name);
				YYERROR;
			}
			(void)strlcpy(rule->r_value.relayhost.authtable, t->t_name,
			    sizeof(rule->r_value.relayhost.authtable));
		}
break;
case 94:
#line 828 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (!(rule->r_value.relayhost.flags & F_SSL)) {
				yyerror("cannot \"verify\" with insecure protocol");
				YYERROR;
			}
			rule->r_value.relayhost.flags |= F_TLS_VERIFY;
		}
break;
case 98:
#line 842 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			memset(conf->sc_bounce_warn, 0, sizeof conf->sc_bounce_warn);
		}
break;
case 100:
#line 845 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (strlen(yyvsp[0].v.string) != 1) {
				yyerror("subaddressing-delimiter must be one character");
				free(yyvsp[0].v.string);
				YYERROR;
			}

			if (isspace((int)*yyvsp[0].v.string) ||  !isprint((int)*yyvsp[0].v.string) || *yyvsp[0].v.string== '@') {
				yyerror("subaddressing-delimiter uses invalid character");
				free(yyvsp[0].v.string);
				YYERROR;
			}

			conf->sc_subaddressing_delim = yyvsp[0].v.string;
		}
break;
case 101:
#line 860 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			conf->sc_queue_flags |= QUEUE_COMPRESSION;
		}
break;
case 102:
#line 863 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			conf->sc_queue_flags |= QUEUE_ENCRYPTION;
		}
break;
case 103:
#line 866 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (strcasecmp(yyvsp[0].v.string, "stdin") == 0 || strcasecmp(yyvsp[0].v.string, "-") == 0) {
				conf->sc_queue_key = "stdin";
				free(yyvsp[0].v.string);
			}
			else
				conf->sc_queue_key = yyvsp[0].v.string;
			conf->sc_queue_flags |= QUEUE_ENCRYPTION;
		}
break;
case 104:
#line 875 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			conf->sc_qexpire = delaytonum(yyvsp[0].v.string);
			if (conf->sc_qexpire == -1) {
				yyerror("invalid expire delay: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 105:
#line 884 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			conf->sc_maxsize = yyvsp[0].v.number;
		}
break;
case 106:
#line 887 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			conf->sc_mta_max_deferred = yyvsp[0].v.number;
		}
break;
case 109:
#line 892 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct mta_limits	*d;

			limits = dict_get(conf->sc_limits_dict, yyvsp[0].v.string);
			if (limits == NULL) {
				limits = xcalloc(1, sizeof(*limits), "mta_limits");
				dict_xset(conf->sc_limits_dict, yyvsp[0].v.string, limits);
				d = dict_xget(conf->sc_limits_dict, "default");
				memmove(limits, d, sizeof(*limits));
			}
			free(yyvsp[0].v.string);
		}
break;
case 111:
#line 904 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			limits = dict_get(conf->sc_limits_dict, "default");
		}
break;
case 114:
#line 908 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			memset(&listen_opts, 0, sizeof listen_opts);
			listen_opts.family = AF_UNSPEC;
			listen_opts.flags |= F_EXT_DSN;
		}
break;
case 116:
#line 913 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			char buf[HOST_NAME_MAX+1];

			/* if not catchall, check that it is a valid domain */
			if (strcmp(yyvsp[0].v.string, "*") != 0) {
				if (!res_hnok(yyvsp[0].v.string)) {
					yyerror("not a valid domain name: %s", yyvsp[0].v.string);
					free(yyvsp[0].v.string);
					YYERROR;
				}
			}
			xlowercase(buf, yyvsp[0].v.string, sizeof(buf));
			free(yyvsp[0].v.string);
			pki = dict_get(conf->sc_pki_dict, buf);
			if (pki == NULL) {
				pki = xcalloc(1, sizeof *pki, "parse:pki");
				(void)strlcpy(pki->pki_name, buf, sizeof(pki->pki_name));
				dict_set(conf->sc_pki_dict, pki->pki_name, pki);
			}
		}
break;
case 118:
#line 933 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			char buf[HOST_NAME_MAX+1];

			/* if not catchall, check that it is a valid domain */
			if (strcmp(yyvsp[0].v.string, "*") != 0) {
				if (!res_hnok(yyvsp[0].v.string)) {
					yyerror("not a valid domain name: %s", yyvsp[0].v.string);
					free(yyvsp[0].v.string);
					YYERROR;
				}
			}
			xlowercase(buf, yyvsp[0].v.string, sizeof(buf));
			free(yyvsp[0].v.string);
			sca = dict_get(conf->sc_ca_dict, buf);
			if (sca == NULL) {
				sca = xcalloc(1, sizeof *sca, "parse:ca");
				(void)strlcpy(sca->ca_name, buf, sizeof(sca->ca_name));
				dict_set(conf->sc_ca_dict, sca->ca_name, sca);
			}
		}
break;
case 120:
#line 953 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			conf->sc_tls_ciphers = yyvsp[0].v.string;
		}
break;
case 121:
#line 958 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			char *p, *backend, *config;

			p = yyvsp[0].v.string;
			if (*p == '/') {
				backend = "static";
				config = yyvsp[0].v.string;
			}
			else {
				backend = yyvsp[0].v.string;
				config = NULL;
				for (p = yyvsp[0].v.string; *p && *p != ':'; p++)
					;
				if (*p == ':') {
					*p = '\0';
					backend = yyvsp[0].v.string;
					config  = p+1;
				}
			}
			if (config != NULL && *config != '/') {
				yyerror("invalid backend parameter for table: %s",
				    yyvsp[-1].v.string);
				free(yyvsp[-1].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			table = table_create(backend, yyvsp[-1].v.string, NULL, config);
			if (!table_config(table)) {
				yyerror("invalid configuration file %s for table %s",
				    config, table->t_name);
				free(yyvsp[-1].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[-1].v.string);
			free(yyvsp[0].v.string);
		}
break;
case 122:
#line 995 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			table = table_create("static", yyvsp[0].v.string, NULL, NULL);
			free(yyvsp[0].v.string);
		}
break;
case 123:
#line 998 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			table = NULL;
		}
break;
case 126:
#line 1005 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			table->t_type = T_HASH;
			table_add(table, yyvsp[-2].v.string, yyvsp[0].v.string);
			free(yyvsp[-2].v.string);
			free(yyvsp[0].v.string);
		}
break;
case 129:
#line 1017 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			table->t_type = T_LIST;
			table_add(table, yyvsp[0].v.string, NULL);
			free(yyvsp[0].v.string);
		}
break;
case 132:
#line 1028 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{ }
break;
case 133:
#line 1029 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{ }
break;
case 134:
#line 1032 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table	*t;

			t = table_create("static", NULL, NULL, NULL);
			t->t_type = T_LIST;
			table_add(t, yyvsp[0].v.string, NULL);
			free(yyvsp[0].v.string);
			yyval.v.table = t;
		}
break;
case 135:
#line 1041 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			table = table_create("static", NULL, NULL, NULL);
		}
break;
case 136:
#line 1043 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			yyval.v.table = table;
		}
break;
case 137:
#line 1048 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table	*t;

			if ((t = table_find(yyvsp[-1].v.string, NULL)) == NULL) {
				yyerror("no such table: %s", yyvsp[-1].v.string);
				free(yyvsp[-1].v.string);
				YYERROR;
			}
			free(yyvsp[-1].v.string);
			yyval.v.table = t;
		}
break;
case 138:
#line 1061 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{ yyval.v.table = yyvsp[0].v.table; }
break;
case 139:
#line 1062 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{ yyval.v.table = yyvsp[0].v.table; }
break;
case 140:
#line 1065 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table   *t = yyvsp[0].v.table;

			if (!table_check_use(t, T_DYNAMIC|T_HASH, K_ALIAS)) {
				yyerror("invalid use of table \"%s\" as ALIAS parameter",
				    t->t_name);
				YYERROR;
			}

			yyval.v.table = t;
		}
break;
case 141:
#line 1078 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table   *t = yyvsp[0].v.table;

			if (!table_check_use(t, T_DYNAMIC|T_HASH, K_ALIAS)) {
				yyerror("invalid use of table \"%s\" as VIRTUAL parameter",
				    t->t_name);
				YYERROR;
			}
			yyval.v.table = t;
		}
break;
case 142:
#line 1090 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (rule->r_mapping) {
				yyerror("alias specified multiple times");
				YYERROR;
			}
			rule->r_desttype = DEST_DOM;
			rule->r_mapping = yyvsp[0].v.table;
		}
break;
case 143:
#line 1098 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (rule->r_mapping) {
				yyerror("virtual specified multiple times");
				YYERROR;
			}
			rule->r_desttype = DEST_VDOM;
			rule->r_mapping = yyvsp[0].v.table;
		}
break;
case 144:
#line 1108 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table   *t = yyvsp[0].v.table;

			if (rule->r_userbase) {
				yyerror("userbase specified multiple times");
				YYERROR;
			}
			if (!table_check_use(t, T_DYNAMIC|T_HASH, K_USERINFO)) {
				yyerror("invalid use of table \"%s\" as USERBASE parameter",
				    t->t_name);
				YYERROR;
			}
			rule->r_userbase = t;
		}
break;
case 145:
#line 1124 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (strlcpy(rule->r_delivery_user, yyvsp[0].v.string,
			    sizeof(rule->r_delivery_user))
			    >= sizeof(rule->r_delivery_user))
				fatal("username too long");
			free(yyvsp[0].v.string);
		}
break;
case 146:
#line 1131 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{}
break;
case 147:
#line 1134 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_action = A_MAILDIR;
			if (strlcpy(rule->r_value.buffer, "~/Maildir",
			    sizeof(rule->r_value.buffer)) >=
			    sizeof(rule->r_value.buffer))
				fatal("pathname too long");
		}
break;
case 148:
#line 1141 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_action = A_MAILDIR;
			if (strlcpy(rule->r_value.buffer, yyvsp[0].v.string,
			    sizeof(rule->r_value.buffer)) >=
			    sizeof(rule->r_value.buffer))
				fatal("pathname too long");
			free(yyvsp[0].v.string);
		}
break;
case 149:
#line 1149 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_action = A_MBOX;
			if (strlcpy(rule->r_value.buffer, _PATH_MAILDIR "/%u",
			    sizeof(rule->r_value.buffer))
			    >= sizeof(rule->r_value.buffer))
				fatal("pathname too long");
		}
break;
case 150:
#line 1156 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_action = A_LMTP;
			if (strchr(yyvsp[-1].v.string, ':') || yyvsp[-1].v.string[0] == '/') {
				if (strlcpy(rule->r_value.buffer, yyvsp[-1].v.string,
					sizeof(rule->r_value.buffer))
					>= sizeof(rule->r_value.buffer))
					fatal("lmtp destination too long");
			} else
				fatal("invalid lmtp destination");
			free(yyvsp[-1].v.string);
		}
break;
case 151:
#line 1167 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_action = A_LMTP;
			if (strchr(yyvsp[-2].v.string, ':') || yyvsp[-2].v.string[0] == '/') {
				if (strlcpy(rule->r_value.buffer, yyvsp[-2].v.string,
					sizeof(rule->r_value.buffer))
					>= sizeof(rule->r_value.buffer))
					fatal("lmtp destination too long");
				if (strlcat(rule->r_value.buffer, " rcpt-to",
					sizeof(rule->r_value.buffer))
					>= sizeof(rule->r_value.buffer))
					fatal("lmtp recipient too long");
			} else
				fatal("invalid lmtp destination");
			free(yyvsp[-2].v.string);
		}
break;
case 152:
#line 1182 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_action = A_MDA;
			if (strlcpy(rule->r_value.buffer, yyvsp[-1].v.string,
			    sizeof(rule->r_value.buffer))
			    >= sizeof(rule->r_value.buffer))
				fatal("command too long");
			free(yyvsp[-1].v.string);
		}
break;
case 153:
#line 1192 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_action = A_RELAY;
		}
break;
case 154:
#line 1195 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule->r_action = A_RELAYVIA;
			if (!text_to_relayhost(&rule->r_value.relayhost, yyvsp[0].v.string)) {
				yyerror("error: invalid url: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 155:
#line 1203 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			/* no worries, F_AUTH cant be set without SSL */
			if (rule->r_value.relayhost.flags & F_AUTH) {
				if (rule->r_value.relayhost.authtable[0] == '\0') {
					yyerror("error: auth without auth table");
					YYERROR;
				}
			}
		}
break;
case 156:
#line 1214 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{ yyval.v.number = 1; }
break;
case 157:
#line 1215 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{ yyval.v.number = 0; }
break;
case 158:
#line 1218 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table   *t = yyvsp[0].v.table;

			if (rule->r_sources) {
				yyerror("from specified multiple times");
				YYERROR;
			}
			if (!table_check_use(t, T_DYNAMIC|T_LIST, K_NETADDR)) {
				yyerror("invalid use of table \"%s\" as FROM parameter",
				    t->t_name);
				YYERROR;
			}
			rule->r_notsources = yyvsp[-2].v.number;
			rule->r_sources = t;
		}
break;
case 159:
#line 1233 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (rule->r_sources) {
				yyerror("from specified multiple times");
				YYERROR;
			}
			rule->r_sources = table_find("<anyhost>", NULL);
			rule->r_notsources = yyvsp[-1].v.number;
		}
break;
case 160:
#line 1241 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (rule->r_sources) {
				yyerror("from specified multiple times");
				YYERROR;
			}
			rule->r_sources = table_find("<localhost>", NULL);
			rule->r_notsources = yyvsp[-1].v.number;
		}
break;
case 161:
#line 1251 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table   *t = yyvsp[0].v.table;

			if (rule->r_destination) {
				yyerror("for specified multiple times");
				YYERROR;
			}
			if (!table_check_use(t, T_DYNAMIC|T_LIST, K_DOMAIN)) {
				yyerror("invalid use of table \"%s\" as DOMAIN parameter",
				    t->t_name);
				YYERROR;
			}
			rule->r_notdestination = yyvsp[-2].v.number;
			rule->r_destination = t;
		}
break;
case 162:
#line 1266 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (rule->r_destination) {
				yyerror("for specified multiple times");
				YYERROR;
			}
			rule->r_notdestination = yyvsp[-1].v.number;
			rule->r_destination = table_find("<anydestination>", NULL);
		}
break;
case 163:
#line 1274 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (rule->r_destination) {
				yyerror("for specified multiple times");
				YYERROR;
			}
			rule->r_notdestination = yyvsp[-1].v.number;
			rule->r_destination = table_find("<localnames>", NULL);
		}
break;
case 164:
#line 1284 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table   *t = yyvsp[0].v.table;

			if (rule->r_senders) {
				yyerror("sender specified multiple times");
				YYERROR;
			}

			if (!table_check_use(t, T_DYNAMIC|T_LIST, K_MAILADDR)) {
				yyerror("invalid use of table \"%s\" as SENDER parameter",
				    t->t_name);
				YYERROR;
			}
			rule->r_notsenders = yyvsp[-1].v.number;
			rule->r_senders = t;
		}
break;
case 165:
#line 1302 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			struct table   *t = yyvsp[0].v.table;

			if (rule->r_recipients) {
				yyerror("recipient specified multiple times");
				YYERROR;
			}

			if (!table_check_use(t, T_DYNAMIC|T_LIST, K_MAILADDR)) {
				yyerror("invalid use of table \"%s\" as RECIPIENT parameter",
				    t->t_name);
				YYERROR;
			}
			rule->r_notrecipients = yyvsp[-1].v.number;
			rule->r_recipients = t;
		}
break;
case 166:
#line 1320 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (rule->r_forwardonly) {
				yyerror("forward-only specified multiple times");
				YYERROR;
			}
			rule->r_forwardonly = 1;
		}
break;
case 167:
#line 1329 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (rule->r_qexpire != -1) {
				yyerror("expire specified multiple times");
				YYERROR;
			}
			rule->r_qexpire = delaytonum(yyvsp[0].v.string);
			if (rule->r_qexpire == -1) {
				yyerror("invalid expire delay: %s", yyvsp[0].v.string);
				free(yyvsp[0].v.string);
				YYERROR;
			}
			free(yyvsp[0].v.string);
		}
break;
case 187:
#line 1375 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule = xcalloc(1, sizeof(*rule), "parse rule: ACCEPT");
			rule->r_id = ++ruleid;
			rule->r_action = A_NONE;
			rule->r_decision = R_ACCEPT;
			rule->r_desttype = DEST_DOM;
			rule->r_qexpire = -1;
		}
break;
case 188:
#line 1382 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (!rule->r_sources)
				rule->r_sources = table_find("<localhost>", NULL);
			if (!rule->r_destination)
			 	rule->r_destination = table_find("<localnames>", NULL);
			if (!rule->r_userbase)
				rule->r_userbase = table_find("<getpwnam>", NULL);
			if (rule->r_qexpire == -1)
				rule->r_qexpire = conf->sc_qexpire;
			if (rule->r_action == A_RELAY || rule->r_action == A_RELAYVIA) {
				if (rule->r_userbase != table_find("<getpwnam>", NULL)) {
					yyerror("userbase may not be used with a relay rule");
					YYERROR;
				}
				if (rule->r_mapping) {
					yyerror("aliases/virtual may not be used with a relay rule");
					YYERROR;
				}
			}
			if (rule->r_forwardonly && rule->r_action != A_NONE) {
				yyerror("forward-only may not be used with a default action");
				YYERROR;
			}
			TAILQ_INSERT_TAIL(conf->sc_rules, rule, r_entry);
			rule = NULL;
		}
break;
case 189:
#line 1408 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			rule = xcalloc(1, sizeof(*rule), "parse rule: REJECT");
			rule->r_id = ++ruleid;
			rule->r_decision = R_REJECT;
			rule->r_desttype = DEST_DOM;
		}
break;
case 190:
#line 1413 "/usr/src/usr.sbin/smtpd/smtpctl/../parse.y"
{
			if (!rule->r_sources)
				rule->r_sources = table_find("<localhost>", NULL);
			if (!rule->r_destination)
				rule->r_destination = table_find("<localnames>", NULL);
			TAILQ_INSERT_TAIL(conf->sc_rules, rule, r_entry);
			rule = NULL;
		}
break;
#line 3465 "parse.c"
    }
    yyssp -= yym;
    yystate = *yyssp;
    yyvsp -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
#endif
        yystate = YYFINAL;
        *++yyssp = YYFINAL;
        *++yyvsp = yyval;
        if (yychar < 0)
        {
            if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yyssp, yystate);
#endif
    if (yyssp >= yysslim && yygrowstack())
    {
        goto yyoverflow;
    }
    *++yyssp = yystate;
    *++yyvsp = yyval;
    goto yyloop;
yyoverflow:
    yyerror("yacc stack overflow");
yyabort:
    if (yyss)
            free(yyss);
    if (yyvs)
            free(yyvs);
    yyss = yyssp = NULL;
    yyvs = yyvsp = NULL;
    yystacksize = 0;
    return (1);
yyaccept:
    if (yyss)
            free(yyss);
    if (yyvs)
            free(yyvs);
    yyss = yyssp = NULL;
    yyvs = yyvsp = NULL;
    yystacksize = 0;
    return (0);
}

Generated by: GCOVR (Version 3.3)