From f467bc8f13767fbdd1a61174b4cad9b839f72035 Mon Sep 17 00:00:00 2001 From: Alexander Skovpen Date: Tue, 10 Jun 2014 21:27:30 +0400 Subject: [PATCH] added crypt support --- debian/Makefile | 38 +- source/Makefile | 15 +- source/Makefile.in | 3 +- source/bforce/expression.c | 2596 +++++++++++++++++++++--------- source/bforce/prot_binkp.c | 20 +- source/bforce/prot_binkp_crypt.c | 148 ++ source/bforce/prot_binkp_misc.c | 4 + source/include/config.h | 2 +- source/include/prot_binkp.h | 11 + 9 files changed, 2090 insertions(+), 747 deletions(-) create mode 100644 source/bforce/prot_binkp_crypt.c diff --git a/debian/Makefile b/debian/Makefile index aef82e8..4ba6be0 100644 --- a/debian/Makefile +++ b/debian/Makefile @@ -33,9 +33,9 @@ POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : -build_triplet = i686-pc-linux-gnu -host_triplet = i686-pc-linux-gnu -target_triplet = i686-pc-linux-gnu +build_triplet = x86_64-unknown-linux-gnu +host_triplet = x86_64-unknown-linux-gnu +target_triplet = x86_64-unknown-linux-gnu subdir = ../debian DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in am__aclocal_m4_deps = $(top_srcdir)/configure.in @@ -56,38 +56,38 @@ ECHO_N = -n ECHO_T = EGREP = /bin/grep -E EXEEXT = -GROUP = sergey +GROUP = ftn INSTALL_DATA = ${INSTALL} -m 644 INSTALL_PROGRAM = ${INSTALL} INSTALL_SCRIPT = ${INSTALL} LDFLAGS = LIBOBJS = -LIBS = -lrt +LIBS = LTLIBOBJS = OBJEXT = o -OWNER = sergey +OWNER = ftn PACKAGE_BUGREPORT = sergey@fidoman.ru PACKAGE_NAME = bforce PACKAGE_STRING = bforce 0.24 PACKAGE_TARNAME = bforce PACKAGE_VERSION = 0.24 PATH_SEPARATOR = : -SHELL = /bin/bash -YACC = byacc +SHELL = /bin/sh +YACC = bison -y ac_ct_CC = gcc bindir = ${exec_prefix}/bin -build = i686-pc-linux-gnu +build = x86_64-unknown-linux-gnu build_alias = -build_cpu = i686 +build_cpu = x86_64 build_os = linux-gnu -build_vendor = pc +build_vendor = unknown datadir = ${prefix}/share exec_prefix = ${prefix} -host = i686-pc-linux-gnu +host = x86_64-unknown-linux-gnu host_alias = -host_cpu = i686 +host_cpu = x86_64 host_os = linux-gnu -host_vendor = pc +host_vendor = unknown includedir = ${prefix}/include infodir = ${prefix}/share/info libdir = ${exec_prefix}/lib @@ -95,16 +95,16 @@ libexecdir = ${exec_prefix}/libexec localstatedir = ${prefix}/var mandir = ${prefix}/share/man oldincludedir = /usr/include -prefix = /home/sergey/bforce +prefix = /usr/local program_transform_name = s,x,x, sbindir = ${exec_prefix}/sbin sharedstatedir = ${prefix}/com -sysconfdir = ${prefix}/etc -target = i686-pc-linux-gnu +sysconfdir = /usr/local/etc/ftn/bforce +target = x86_64-unknown-linux-gnu target_alias = -target_cpu = i686 +target_cpu = x86_64 target_os = linux-gnu -target_vendor = pc +target_vendor = unknown # $Id$ EXTRA_DIST = copyright changelog rules conffiles \ diff --git a/source/Makefile b/source/Makefile index c804bb5..5b90c43 100644 --- a/source/Makefile +++ b/source/Makefile @@ -6,14 +6,14 @@ # $Id$ # -prefix=/home/sergey/bforce +prefix=/usr/local exec_prefix=${prefix} CC = gcc INCLUDES = -I./include CFLAGS = -g -O2 -fno-builtin -LIBS = -lrt -YACC = byacc +LIBS = +YACC = bison -y INSTALL = /usr/bin/install -c INSTALL_PROGRAM = ${INSTALL} INSTALL_DATA = ${INSTALL} -m 644 @@ -21,9 +21,9 @@ SRCDIR = . SRCDIRCONF = $(SRCDIR)/../examples CONTRIBDIR = $(SRCDIR)/../contrib -OWNER = sergey -GROUP = sergey -CONFDIR = ${prefix}/etc +OWNER = ftn +GROUP = ftn +CONFDIR = /usr/local/etc/ftn/bforce BINDIR = ${exec_prefix}/bin LOGDIR = /var/log/bforce SPOOLDIR = /var/spool/bforce @@ -103,7 +103,8 @@ BFORCE_OBJS = bforce/bforce.o \ bforce/u_misc.o bforce/u_string.o \ bforce/u_time.o bforce/u_file.o \ bforce/u_pkt.o bforce/u_recode.o \ - bforce/u_plock.o bforce/netspool.o + bforce/u_plock.o bforce/netspool.o \ + bforce/prot_binkp_crypt.o .c.o: @echo Compiling $*.c diff --git a/source/Makefile.in b/source/Makefile.in index 0cdcb90..8de31a3 100644 --- a/source/Makefile.in +++ b/source/Makefile.in @@ -103,7 +103,8 @@ BFORCE_OBJS = bforce/bforce.o \ bforce/u_misc.o bforce/u_string.o \ bforce/u_time.o bforce/u_file.o \ bforce/u_pkt.o bforce/u_recode.o \ - bforce/u_plock.o bforce/netspool.o + bforce/u_plock.o bforce/netspool.o \ + bforce/prot_binkp_crypt.o .c.o: @echo Compiling $*.c diff --git a/source/bforce/expression.c b/source/bforce/expression.c index 9bcc369..e13e22f 100644 --- a/source/bforce/expression.c +++ b/source/bforce/expression.c @@ -1,317 +1,1905 @@ +/* A Bison parser, made by GNU Bison 2.4.3. */ + +/* Skeleton implementation for Bison's Yacc-like parsers in C + + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, + 2009, 2010 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "2.4.3" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + + + +/* Copy the first part of user declarations. */ + +/* Line 189 of yacc.c */ +#line 48 "bforce/expression.y" + +#include "includes.h" +#include "confread.h" +#include "util.h" +#include "logger.h" +#include "session.h" +#include "nodelist.h" +#include "io.h" + +static struct tm *now = NULL; +static int expr_result = 0; +static char *expr_p_pos = NULL; +static char *expr_p_text = NULL; + +/* + * These are expression element checkers (not only) + * Return values: + * 0 - FALSE + * 1 - TRUE + * -1 - cannot check, because some data is not available yet + * -2 - invalid element (we should not check this expression more) + */ +static int expr_check_incoming(void); +static int expr_check_outgoing(void); +static int expr_check_protected(void); +static int expr_check_listed(void); +static int expr_check_logic(int e1, int op, int e2); +static int expr_check_phone(const char *phone); +static int expr_check_arop(int num1, int op, int num2); +static int expr_check_flag(const char *str); +static int expr_check_exec(const char *str); +static int expr_check_exist(const char *str); +static int expr_check_port(const char *str); +static int expr_check_mailer(const char *str); +static int expr_check_addr(const char *str); +static int expr_check_time(const char *str); + +static int yylex(void); +static int yyparse(void); +static int yyerror(const char *s); + + + +/* Line 189 of yacc.c */ +#line 116 "y.tab.c" + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + COMMA = 258, + TEXT = 259, + NUMBER = 260, + INCOMING = 261, + OUTGOING = 262, + LISTED = 263, + PROTECTED = 264, + CONNSPEED = 265, + EXEC = 266, + EXIST = 267, + PORT = 268, + MAILER = 269, + TZ = 270, + FLAG = 271, + SPEED = 272, + PHONE = 273, + TIME = 274, + ADDRESS = 275, + EQ = 276, + NE = 277, + GT = 278, + GE = 279, + LT = 280, + LE = 281, + AND = 282, + OR = 283, + NOT = 284, + XOR = 285, + OPENB = 286, + CLOSEB = 287, + AROP = 288, + LOGOP = 289 + }; +#endif +/* Tokens. */ +#define COMMA 258 +#define TEXT 259 +#define NUMBER 260 +#define INCOMING 261 +#define OUTGOING 262 +#define LISTED 263 +#define PROTECTED 264 +#define CONNSPEED 265 +#define EXEC 266 +#define EXIST 267 +#define PORT 268 +#define MAILER 269 +#define TZ 270 +#define FLAG 271 +#define SPEED 272 +#define PHONE 273 +#define TIME 274 +#define ADDRESS 275 +#define EQ 276 +#define NE 277 +#define GT 278 +#define GE 279 +#define LT 280 +#define LE 281 +#define AND 282 +#define OR 283 +#define NOT 284 +#define XOR 285 +#define OPENB 286 +#define CLOSEB 287 +#define AROP 288 +#define LOGOP 289 + + + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef int YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +#endif + + +/* Copy the second part of user declarations. */ + + +/* Line 264 of yacc.c */ +#line 226 "y.tab.c" + +#ifdef short +# undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#elif (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +typedef signed char yytype_int8; +#else +typedef short int yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(e) ((void) (e)) +#else +# define YYUSE(e) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ #ifndef lint -static const char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93"; +# define YYID(n) (n) +#else +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID (int yyi) +#else +static int +YYID (yyi) + int yyi; +#endif +{ + return yyi; +} +#endif + +#if ! defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef _STDLIB_H +# define _STDLIB_H 1 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined _STDLIB_H \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef _STDLIB_H +# define _STDLIB_H 1 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) + +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 35 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 43 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 35 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 6 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 25 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 46 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 289 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint8 yyprhs[] = +{ + 0, 0, 3, 5, 7, 10, 14, 18, 20, 22, + 24, 26, 29, 33, 37, 41, 44, 47, 50, 53, + 56, 59, 61, 63, 67, 69 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int8 yyrhs[] = +{ + 36, 0, -1, 37, -1, 38, -1, 29, 37, -1, + 37, 34, 37, -1, 31, 37, 32, -1, 6, -1, + 7, -1, 8, -1, 9, -1, 16, 39, -1, 10, + 33, 5, -1, 17, 33, 5, -1, 15, 33, 5, + -1, 18, 4, -1, 19, 40, -1, 11, 4, -1, + 12, 4, -1, 13, 4, -1, 14, 4, -1, 4, + -1, 4, -1, 4, 3, 39, -1, 4, -1, 4, + 3, 40, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint8 yyrline[] = +{ + 0, 92, 92, 98, 103, 111, 115, 121, 125, 129, + 133, 137, 141, 148, 155, 159, 163, 167, 171, 175, + 179, 183, 190, 194, 199, 205 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "COMMA", "TEXT", "NUMBER", "INCOMING", + "OUTGOING", "LISTED", "PROTECTED", "CONNSPEED", "EXEC", "EXIST", "PORT", + "MAILER", "TZ", "FLAG", "SPEED", "PHONE", "TIME", "ADDRESS", "EQ", "NE", + "GT", "GE", "LT", "LE", "AND", "OR", "NOT", "XOR", "OPENB", "CLOSEB", + "AROP", "LOGOP", "$accept", "fullline", "expression", "elemexp", + "flagstring", "timestring", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const yytype_uint16 yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint8 yyr1[] = +{ + 0, 35, 36, 37, 37, 37, 37, 38, 38, 38, + 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, + 38, 38, 39, 39, 40, 40 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 1, 1, 2, 3, 3, 1, 1, 1, + 1, 2, 3, 3, 3, 2, 2, 2, 2, 2, + 2, 1, 1, 3, 1, 3 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const yytype_uint8 yydefact[] = +{ + 0, 21, 7, 8, 9, 10, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, + 3, 0, 17, 18, 19, 20, 0, 22, 11, 0, + 15, 24, 16, 4, 0, 1, 0, 12, 14, 0, + 13, 0, 6, 5, 23, 25 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int8 yydefgoto[] = +{ + -1, 18, 19, 20, 28, 32 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -33 +static const yytype_int8 yypact[] = +{ + -4, -33, -33, -33, -33, -33, -32, 15, 17, 18, + 19, -9, 22, -5, 25, 26, -4, -4, 31, -2, + -33, 28, -33, -33, -33, -33, 29, 32, -33, 33, + -33, 34, -33, -2, -14, -33, -4, -33, -33, 22, + -33, 26, -33, -2, -33, -33 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int8 yypgoto[] = +{ + -33, -33, 0, -33, 1, 2 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -1 +static const yytype_uint8 yytable[] = +{ + 1, 21, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 33, 34, 42, 22, + 36, 23, 24, 25, 26, 16, 27, 17, 29, 30, + 31, 35, 36, 37, 38, 39, 43, 41, 40, 0, + 44, 0, 0, 45 +}; + +static const yytype_int8 yycheck[] = +{ + 4, 33, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 16, 17, 32, 4, + 34, 4, 4, 4, 33, 29, 4, 31, 33, 4, + 4, 0, 34, 5, 5, 3, 36, 3, 5, -1, + 39, -1, -1, 41 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint8 yystos[] = +{ + 0, 4, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 29, 31, 36, 37, + 38, 33, 4, 4, 4, 4, 33, 4, 39, 33, + 4, 4, 40, 37, 37, 0, 34, 5, 5, 3, + 5, 3, 32, 37, 39, 40 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. However, + YYFAIL appears to be in use. Nevertheless, it is formally deprecated + in Bison 2.4.2's NEWS entry, where a plan to phase it out is + discussed. */ + +#define YYFAIL goto yyerrlab +#if defined YYFAIL + /* This is here to suppress warnings from the GCC cpp's + -Wunused-macros. Normally we don't worry about that warning, but + some users do, and we want to make it easy for users to remove + YYFAIL uses, which will produce warnings from Bison 2.5. */ +#endif + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = YYTRANSLATE (yychar); \ + YYPOPSTACK (1); \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) + + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (YYID (N)) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (YYID (0)) #endif -#define YYBYACC 1 -#define YYMAJOR 1 -#define YYMINOR 9 -#define YYPATCH 20120115 -#define YYEMPTY (-1) -#define yyclearin (yychar = YYEMPTY) -#define yyerrok (yyerrflag = 0) -#define YYRECOVERING() (yyerrflag != 0) +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef YY_LOCATION_PRINT +# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (YYLEX_PARAM) +#else +# define YYLEX yylex () +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_value_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (!yyvaluep) + return; +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { + default: + break; + } +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + yy_symbol_value_print (yyoutput, yytype, yyvaluep); + YYFPRINTF (yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +#else +static void +yy_stack_print (yybottom, yytop) + yytype_int16 *yybottom; + yytype_int16 *yytop; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_reduce_print (YYSTYPE *yyvsp, int yyrule) +#else +static void +yy_reduce_print (yyvsp, yyrule) + YYSTYPE *yyvsp; + int yyrule; +#endif +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)]) + ); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, Rule); \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen (const char *yystr) +#else +static YYSIZE_T +yystrlen (yystr) + const char *yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char * +yystpcpy (char *yydest, const char *yysrc) +#else +static char * +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +#endif +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into YYRESULT an error message about the unexpected token + YYCHAR while in state YYSTATE. Return the number of bytes copied, + including the terminating null byte. If YYRESULT is null, do not + copy anything; just return the number of bytes that would be + copied. As a special case, return 0 if an ordinary "syntax error" + message will do. Return YYSIZE_MAXIMUM if overflow occurs during + size calculation. */ +static YYSIZE_T +yysyntax_error (char *yyresult, int yystate, int yychar) +{ + int yyn = yypact[yystate]; + + if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) + return 0; + else + { + int yytype = YYTRANSLATE (yychar); + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + int yysize_overflow = 0; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + int yyx; + +# if 0 + /* This is so xgettext sees the translatable formats that are + constructed on the fly. */ + YY_("syntax error, unexpected %s"); + YY_("syntax error, unexpected %s, expecting %s"); + YY_("syntax error, unexpected %s, expecting %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); +# endif + char *yyfmt; + char const *yyf; + static char const yyunexpected[] = "syntax error, unexpected %s"; + static char const yyexpecting[] = ", expecting %s"; + static char const yyor[] = " or %s"; + char yyformat[sizeof yyunexpected + + sizeof yyexpecting - 1 + + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) + * (sizeof yyor - 1))]; + char const *yyprefix = yyexpecting; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 1; + + yyarg[0] = yytname[yytype]; + yyfmt = yystpcpy (yyformat, yyunexpected); + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + yyformat[sizeof yyunexpected - 1] = '\0'; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr (0, yytname[yyx]); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + yyfmt = yystpcpy (yyfmt, yyprefix); + yyprefix = yyor; + } + + yyf = YY_(yyformat); + yysize1 = yysize + yystrlen (yyf); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + + if (yysize_overflow) + return YYSIZE_MAXIMUM; + + if (yyresult) + { + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + char *yyp = yyresult; + int yyi = 0; + while ((*yyp = *yyf) != '\0') + { + if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyf += 2; + } + else + { + yyp++; + yyf++; + } + } + } + return yysize; + } +} +#endif /* YYERROR_VERBOSE */ + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + YYUSE (yyvaluep); + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + +/* Prevent warnings from -Wmissing-prototypes. */ +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + + + +/*-------------------------. +| yyparse or yypush_parse. | +`-------------------------*/ + +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void *YYPARSE_PARAM) +#else +int +yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void) +#else +int +yyparse () + +#endif +#endif +{ + + + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + `yyss': related to states. + `yyvs': related to semantic values. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp; + + YYSIZE_T yystacksize; + + int yyn; + int yyresult; + /* Lookahead token as an internal (translated) token number. */ + int yytoken; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + yytoken = 0; + yyss = yyssa; + yyvs = yyvsa; + yystacksize = YYINITDEPTH; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token. */ + yychar = YYEMPTY; + + yystate = yyn; + *++yyvsp = yylval; + + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: + +/* Line 1464 of yacc.c */ +#line 93 "bforce/expression.y" + { + DEB((D_EVENT, "[yacc] expression return %d", (yyvsp[(1) - (1)]))); + expr_result = (yyvsp[(1) - (1)]); + } + break; + + case 3: + +/* Line 1464 of yacc.c */ +#line 99 "bforce/expression.y" + { + DEB((D_EVENT, "[yacc] elemexp return %d", (yyvsp[(1) - (1)]))); + (yyval) = (yyvsp[(1) - (1)]); + } + break; + + case 4: + +/* Line 1464 of yacc.c */ +#line 104 "bforce/expression.y" + { + DEB((D_EVENT, "[yacc] not exprression %d", (yyvsp[(2) - (2)]))); + if( ((yyvsp[(2) - (2)])) < 0 ) + (yyval) = 0; + else + (yyval) = !((yyvsp[(2) - (2)])); + } + break; + + case 5: + +/* Line 1464 of yacc.c */ +#line 112 "bforce/expression.y" + { + (yyval) = expr_check_logic((yyvsp[(1) - (3)]), (yyvsp[(2) - (3)]), (yyvsp[(3) - (3)])); + } + break; + + case 6: + +/* Line 1464 of yacc.c */ +#line 116 "bforce/expression.y" + { + DEB((D_EVENT, "eventexp: [yacc] backeted.expr %d", (yyvsp[(2) - (3)]))); + (yyval) = (yyvsp[(2) - (3)]); + } + break; + + case 7: + +/* Line 1464 of yacc.c */ +#line 122 "bforce/expression.y" + { + (yyval) = expr_check_incoming(); + } + break; + + case 8: + +/* Line 1464 of yacc.c */ +#line 126 "bforce/expression.y" + { + (yyval) = expr_check_outgoing(); + } + break; + + case 9: + +/* Line 1464 of yacc.c */ +#line 130 "bforce/expression.y" + { + (yyval) = expr_check_listed(); + } + break; + + case 10: + +/* Line 1464 of yacc.c */ +#line 134 "bforce/expression.y" + { + (yyval) = expr_check_protected(); + } + break; + + case 11: + +/* Line 1464 of yacc.c */ +#line 138 "bforce/expression.y" + { + (yyval) = (yyvsp[(2) - (2)]); + } + break; + + case 12: + +/* Line 1464 of yacc.c */ +#line 142 "bforce/expression.y" + { + if( state.valid && state.connspeed > 0 ) + (yyval) = expr_check_arop(state.connspeed, (yyvsp[(2) - (3)]), (yyvsp[(3) - (3)])); + else + (yyval) = -1; + } + break; + + case 13: + +/* Line 1464 of yacc.c */ +#line 149 "bforce/expression.y" + { + if( state.valid && state.node.speed > 0 ) + (yyval) = expr_check_arop(state.node.speed, (yyvsp[(2) - (3)]), (yyvsp[(3) - (3)])); + else + (yyval) = -1; + } + break; + + case 14: + +/* Line 1464 of yacc.c */ +#line 156 "bforce/expression.y" + { + (yyval) = expr_check_arop(time_gmtoffset(), (yyvsp[(2) - (3)]), (yyvsp[(3) - (3)])); + } + break; + + case 15: + +/* Line 1464 of yacc.c */ +#line 160 "bforce/expression.y" + { + (yyval) = expr_check_phone(expr_p_text); + } + break; + + case 16: + +/* Line 1464 of yacc.c */ +#line 164 "bforce/expression.y" + { + (yyval) = (yyvsp[(2) - (2)]); + } + break; + + case 17: + +/* Line 1464 of yacc.c */ +#line 168 "bforce/expression.y" + { + (yyval) = expr_check_exec(expr_p_text); + } + break; + + case 18: + +/* Line 1464 of yacc.c */ +#line 172 "bforce/expression.y" + { + (yyval) = expr_check_exist(expr_p_text); + } + break; + + case 19: + +/* Line 1464 of yacc.c */ +#line 176 "bforce/expression.y" + { + (yyval) = expr_check_port(expr_p_text); + } + break; + + case 20: + +/* Line 1464 of yacc.c */ +#line 180 "bforce/expression.y" + { + (yyval) = expr_check_mailer(expr_p_text); + } + break; + + case 21: + +/* Line 1464 of yacc.c */ +#line 184 "bforce/expression.y" + { + (yyval) = expr_check_addr(expr_p_text); + if( (yyval) == -2 ) + YYABORT; + } + break; + + case 22: + +/* Line 1464 of yacc.c */ +#line 191 "bforce/expression.y" + { + (yyval) = expr_check_flag(expr_p_text); + } + break; + + case 23: + +/* Line 1464 of yacc.c */ +#line 195 "bforce/expression.y" + { + (yyval) = expr_check_logic((yyvsp[(1) - (3)]), OR, (yyvsp[(3) - (3)])); + } + break; + + case 24: + +/* Line 1464 of yacc.c */ +#line 200 "bforce/expression.y" + { + (yyval) = expr_check_time(expr_p_text); + if( (yyval) == -2 ) + YYABORT; + } + break; + + case 25: + +/* Line 1464 of yacc.c */ +#line 206 "bforce/expression.y" + { + (yyval) = expr_check_logic((yyvsp[(1) - (3)]), OR, (yyvsp[(3) - (3)])); + } + break; -#define YYPREFIX "yy" -#define YYPURE 0 -#line 49 "bforce/expression.y" -#include "includes.h" -#include "confread.h" -#include "util.h" -#include "logger.h" -#include "session.h" -#include "nodelist.h" -#include "io.h" +/* Line 1464 of yacc.c */ +#line 1690 "y.tab.c" + default: break; + } + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); -static struct tm *now = NULL; -static int expr_result = 0; -static char *expr_p_pos = NULL; -static char *expr_p_text = NULL; + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); -/* - * These are expression element checkers (not only) - * Return values: - * 0 - FALSE - * 1 - TRUE - * -1 - cannot check, because some data is not available yet - * -2 - invalid element (we should not check this expression more) - */ -static int expr_check_incoming(void); -static int expr_check_outgoing(void); -static int expr_check_protected(void); -static int expr_check_listed(void); -static int expr_check_logic(int e1, int op, int e2); -static int expr_check_phone(const char *phone); -static int expr_check_arop(int num1, int op, int num2); -static int expr_check_flag(const char *str); -static int expr_check_exec(const char *str); -static int expr_check_exist(const char *str); -static int expr_check_port(const char *str); -static int expr_check_mailer(const char *str); -static int expr_check_addr(const char *str); -static int expr_check_time(const char *str); + *++yyvsp = yyval; -static int yylex(void); -static int yyparse(void); -static int yyerror(const char *s); + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ -#line 60 "y.tab.c" + yyn = yyr1[yyn]; -#ifndef YYSTYPE -typedef int YYSTYPE; -#endif + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; -/* compatibility with bison */ -#ifdef YYPARSE_PARAM -/* compatibility with FreeBSD */ -# ifdef YYPARSE_PARAM_TYPE -# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) -# else -# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) -# endif -#else -# define YYPARSE_DECL() yyparse(void) -#endif + goto yynewstate; -/* Parameters sent to lex. */ -#ifdef YYLEX_PARAM -# define YYLEX_DECL() yylex(void *YYLEX_PARAM) -# define YYLEX yylex(YYLEX_PARAM) + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (YY_("syntax error")); #else -# define YYLEX_DECL() yylex(void) -# define YYLEX yylex() -#endif - -/* Parameters sent to yyerror. */ -#ifndef YYERROR_DECL -#define YYERROR_DECL() yyerror(const char *s) -#endif -#ifndef YYERROR_CALL -#define YYERROR_CALL(msg) yyerror(msg) -#endif - -extern int YYPARSE_DECL(); - -#define COMMA 257 -#define TEXT 258 -#define NUMBER 259 -#define INCOMING 260 -#define OUTGOING 261 -#define LISTED 262 -#define PROTECTED 263 -#define CONNSPEED 264 -#define EXEC 265 -#define EXIST 266 -#define PORT 267 -#define MAILER 268 -#define TZ 269 -#define FLAG 270 -#define SPEED 271 -#define PHONE 272 -#define TIME 273 -#define ADDRESS 274 -#define EQ 275 -#define NE 276 -#define GT 277 -#define GE 278 -#define LT 279 -#define LE 280 -#define AND 281 -#define OR 282 -#define NOT 283 -#define XOR 284 -#define OPENB 285 -#define CLOSEB 286 -#define AROP 287 -#define LOGOP 288 -#define YYERRCODE 256 -static const short yylhs[] = { -1, - 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 3, 3, 4, 4, -}; -static const short yylen[] = { 2, - 1, 1, 2, 3, 3, 1, 1, 1, 1, 2, - 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, - 1, 3, 1, 3, -}; -static const short yydefred[] = { 0, - 20, 6, 7, 8, 9, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, - 0, 16, 17, 18, 19, 0, 0, 10, 0, 14, - 0, 15, 0, 0, 0, 11, 13, 0, 12, 0, - 5, 0, 22, 24, -}; -static const short yydgoto[] = { 18, - 19, 20, 28, 32, -}; -static const short yysindex[] = { -251, - 0, 0, 0, 0, 0, -287, -255, -254, -250, -232, - -259, -229, -257, -227, -225, -251, -251, 0, -253, 0, - -223, 0, 0, 0, 0, -222, -219, 0, -220, 0, - -217, 0, -253, -261, -251, 0, 0, -229, 0, -225, - 0, -253, 0, 0, -}; -static const short yyrindex[] = { 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 41, 0, - 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, - 2, 0, 5, 0, 0, 0, 0, 0, 0, 0, - 0, 6, 0, 0, -}; -static const short yygindex[] = { 0, - 7, 0, 8, 3, -}; -#define YYTABLESIZE 292 -static const short yytable[] = { 21, - 21, 23, 22, 23, 3, 4, 1, 24, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 33, 34, 41, 25, 35, 26, 27, 29, - 30, 16, 31, 17, 35, 36, 37, 38, 39, 40, - 1, 42, 44, 0, 0, 43, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 21, 23, 21, 23, - 3, 4, -}; -static const short yycheck[] = { 287, - 0, 0, 258, 258, 0, 0, 258, 258, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 16, 17, 286, 258, 288, 287, 258, 287, - 258, 283, 258, 285, 288, 259, 259, 257, 259, 257, - 0, 35, 40, -1, -1, 38, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 286, 286, 288, 288, - 286, 286, -}; -#define YYFINAL 18 -#ifndef YYDEBUG -#define YYDEBUG 0 + { + YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); + if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) + { + YYSIZE_T yyalloc = 2 * yysize; + if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) + yyalloc = YYSTACK_ALLOC_MAXIMUM; + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yyalloc); + if (yymsg) + yymsg_alloc = yyalloc; + else + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + } + } + + if (0 < yysize && yysize <= yymsg_alloc) + { + (void) yysyntax_error (yymsg, yystate, yychar); + yyerror (yymsg); + } + else + { + yyerror (YY_("syntax error")); + if (yysize != 0) + goto yyexhaustedlab; + } + } #endif -#define YYMAXTOKEN 288 -#if YYDEBUG -static const char *yyname[] = { - -"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"COMMA","TEXT","NUMBER", -"INCOMING","OUTGOING","LISTED","PROTECTED","CONNSPEED","EXEC","EXIST","PORT", -"MAILER","TZ","FLAG","SPEED","PHONE","TIME","ADDRESS","EQ","NE","GT","GE","LT", -"LE","AND","OR","NOT","XOR","OPENB","CLOSEB","AROP","LOGOP", -}; -static const char *yyrule[] = { -"$accept : fullline", -"fullline : expression", -"expression : elemexp", -"expression : NOT expression", -"expression : expression LOGOP expression", -"expression : OPENB expression CLOSEB", -"elemexp : INCOMING", -"elemexp : OUTGOING", -"elemexp : LISTED", -"elemexp : PROTECTED", -"elemexp : FLAG flagstring", -"elemexp : CONNSPEED AROP NUMBER", -"elemexp : SPEED AROP NUMBER", -"elemexp : TZ AROP NUMBER", -"elemexp : PHONE TEXT", -"elemexp : TIME timestring", -"elemexp : EXEC TEXT", -"elemexp : EXIST TEXT", -"elemexp : PORT TEXT", -"elemexp : MAILER TEXT", -"elemexp : TEXT", -"flagstring : TEXT", -"flagstring : TEXT COMMA flagstring", -"timestring : TEXT", -"timestring : TEXT COMMA timestring", + } -}; -#endif -int yydebug; -int yynerrs; -int yyerrflag; -int yychar; -YYSTYPE yyval; -YYSTYPE yylval; + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ -/* define the initial stack-sizes */ -#ifdef YYSTACKSIZE -#undef YYMAXDEPTH -#define YYMAXDEPTH YYSTACKSIZE -#else -#ifdef YYMAXDEPTH -#define YYSTACKSIZE YYMAXDEPTH -#else -#define YYSTACKSIZE 500 -#define YYMAXDEPTH 500 + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + yystos[yystate], yyvsp); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + *++yyvsp = yylval; + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#if !defined(yyoverflow) || YYERROR_VERBOSE +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEMPTY) + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval); + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); #endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); #endif + /* Make sure YYID is used. */ + return YYID (yyresult); +} + -#define YYINITSTACKSIZE 500 -typedef struct { - unsigned stacksize; - short *s_base; - short *s_mark; - short *s_last; - YYSTYPE *l_base; - YYSTYPE *l_mark; -} YYSTACKDATA; -/* variables for the parser stack */ -static YYSTACKDATA yystack; -#line 211 "bforce/expression.y" +/* Line 1684 of yacc.c */ +#line 210 "bforce/expression.y" + #include "expression_lex.c" @@ -545,432 +2133,4 @@ static int yyerror(const char *str) return 0; } -#line 548 "y.tab.c" - -#if YYDEBUG -#include /* needed for printf */ -#endif - -#include /* needed for malloc, etc */ -#include /* needed for memset */ - -/* allocate initial stack or double stack size, up to YYMAXDEPTH */ -static int yygrowstack(YYSTACKDATA *data) -{ - int i; - unsigned newsize; - short *newss; - YYSTYPE *newvs; - - if ((newsize = data->stacksize) == 0) - newsize = YYINITSTACKSIZE; - else if (newsize >= YYMAXDEPTH) - return -1; - else if ((newsize *= 2) > YYMAXDEPTH) - newsize = YYMAXDEPTH; - - i = data->s_mark - data->s_base; - newss = (short *)realloc(data->s_base, newsize * sizeof(*newss)); - if (newss == 0) - return -1; - - data->s_base = newss; - data->s_mark = newss + i; - - newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); - if (newvs == 0) - return -1; - - data->l_base = newvs; - data->l_mark = newvs + i; - - data->stacksize = newsize; - data->s_last = data->s_base + newsize - 1; - return 0; -} - -#if YYPURE || defined(YY_NO_LEAKS) -static void yyfreestack(YYSTACKDATA *data) -{ - free(data->s_base); - free(data->l_base); - memset(data, 0, sizeof(*data)); -} -#else -#define yyfreestack(data) /* nothing */ -#endif - -#define YYABORT goto yyabort -#define YYREJECT goto yyabort -#define YYACCEPT goto yyaccept -#define YYERROR goto yyerrlab - -int -YYPARSE_DECL() -{ - int yym, yyn, yystate; -#if YYDEBUG - const char *yys; - - if ((yys = getenv("YYDEBUG")) != 0) - { - yyn = *yys; - if (yyn >= '0' && yyn <= '9') - yydebug = yyn - '0'; - } -#endif - - yynerrs = 0; - yyerrflag = 0; - yychar = YYEMPTY; - yystate = 0; - -#if YYPURE - memset(&yystack, 0, sizeof(yystack)); -#endif - - if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow; - yystack.s_mark = yystack.s_base; - yystack.l_mark = yystack.l_base; - yystate = 0; - *yystack.s_mark = 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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack)) - { - goto yyoverflow; - } - yystate = yytable[yyn]; - *++yystack.s_mark = yytable[yyn]; - *++yystack.l_mark = yylval; - yychar = YYEMPTY; - 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; - - yyerror("syntax error"); - - goto yyerrlab; - -yyerrlab: - ++yynerrs; - -yyinrecovery: - if (yyerrflag < 3) - { - yyerrflag = 3; - for (;;) - { - if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 && - yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) - { -#if YYDEBUG - if (yydebug) - printf("%sdebug: state %d, error recovery shifting\ - to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]); -#endif - if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack)) - { - goto yyoverflow; - } - yystate = yytable[yyn]; - *++yystack.s_mark = yytable[yyn]; - *++yystack.l_mark = yylval; - goto yyloop; - } - else - { -#if YYDEBUG - if (yydebug) - printf("%sdebug: error recovery discarding state %d\n", - YYPREFIX, *yystack.s_mark); -#endif - if (yystack.s_mark <= yystack.s_base) goto yyabort; - --yystack.s_mark; - --yystack.l_mark; - } - } - } - 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 = YYEMPTY; - 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 = yystack.l_mark[1-yym]; - else - memset(&yyval, 0, sizeof yyval); - switch (yyn) - { -case 1: -#line 93 "bforce/expression.y" - { - DEB((D_EVENT, "[yacc] expression return %d", yystack.l_mark[0])); - expr_result = yystack.l_mark[0]; - } -break; -case 2: -#line 99 "bforce/expression.y" - { - DEB((D_EVENT, "[yacc] elemexp return %d", yystack.l_mark[0])); - yyval = yystack.l_mark[0]; - } -break; -case 3: -#line 104 "bforce/expression.y" - { - DEB((D_EVENT, "[yacc] not exprression %d", yystack.l_mark[0])); - if( (yystack.l_mark[0]) < 0 ) - yyval = 0; - else - yyval = !(yystack.l_mark[0]); - } -break; -case 4: -#line 112 "bforce/expression.y" - { - yyval = expr_check_logic(yystack.l_mark[-2], yystack.l_mark[-1], yystack.l_mark[0]); - } -break; -case 5: -#line 116 "bforce/expression.y" - { - DEB((D_EVENT, "eventexp: [yacc] backeted.expr %d", yystack.l_mark[-1])); - yyval = yystack.l_mark[-1]; - } -break; -case 6: -#line 122 "bforce/expression.y" - { - yyval = expr_check_incoming(); - } -break; -case 7: -#line 126 "bforce/expression.y" - { - yyval = expr_check_outgoing(); - } -break; -case 8: -#line 130 "bforce/expression.y" - { - yyval = expr_check_listed(); - } -break; -case 9: -#line 134 "bforce/expression.y" - { - yyval = expr_check_protected(); - } -break; -case 10: -#line 138 "bforce/expression.y" - { - yyval = yystack.l_mark[0]; - } -break; -case 11: -#line 142 "bforce/expression.y" - { - if( state.valid && state.connspeed > 0 ) - yyval = expr_check_arop(state.connspeed, yystack.l_mark[-1], yystack.l_mark[0]); - else - yyval = -1; - } -break; -case 12: -#line 149 "bforce/expression.y" - { - if( state.valid && state.node.speed > 0 ) - yyval = expr_check_arop(state.node.speed, yystack.l_mark[-1], yystack.l_mark[0]); - else - yyval = -1; - } -break; -case 13: -#line 156 "bforce/expression.y" - { - yyval = expr_check_arop(time_gmtoffset(), yystack.l_mark[-1], yystack.l_mark[0]); - } -break; -case 14: -#line 160 "bforce/expression.y" - { - yyval = expr_check_phone(expr_p_text); - } -break; -case 15: -#line 164 "bforce/expression.y" - { - yyval = yystack.l_mark[0]; - } -break; -case 16: -#line 168 "bforce/expression.y" - { - yyval = expr_check_exec(expr_p_text); - } -break; -case 17: -#line 172 "bforce/expression.y" - { - yyval = expr_check_exist(expr_p_text); - } -break; -case 18: -#line 176 "bforce/expression.y" - { - yyval = expr_check_port(expr_p_text); - } -break; -case 19: -#line 180 "bforce/expression.y" - { - yyval = expr_check_mailer(expr_p_text); - } -break; -case 20: -#line 184 "bforce/expression.y" - { - yyval = expr_check_addr(expr_p_text); - if( yyval == -2 ) - YYABORT; - } -break; -case 21: -#line 191 "bforce/expression.y" - { - yyval = expr_check_flag(expr_p_text); - } -break; -case 22: -#line 195 "bforce/expression.y" - { - yyval = expr_check_logic(yystack.l_mark[-2], OR, yystack.l_mark[0]); - } -break; -case 23: -#line 200 "bforce/expression.y" - { - yyval = expr_check_time(expr_p_text); - if( yyval == -2 ) - YYABORT; - } -break; -case 24: -#line 206 "bforce/expression.y" - { - yyval = expr_check_logic(yystack.l_mark[-2], OR, yystack.l_mark[0]); - } -break; -#line 915 "y.tab.c" - } - yystack.s_mark -= yym; - yystate = *yystack.s_mark; - yystack.l_mark -= 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; - *++yystack.s_mark = YYFINAL; - *++yystack.l_mark = 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, *yystack.s_mark, yystate); -#endif - if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack)) - { - goto yyoverflow; - } - *++yystack.s_mark = (short) yystate; - *++yystack.l_mark = yyval; - goto yyloop; - -yyoverflow: - yyerror("yacc stack overflow"); -yyabort: - yyfreestack(&yystack); - return (1); - -yyaccept: - yyfreestack(&yystack); - return (0); -} diff --git a/source/bforce/prot_binkp.c b/source/bforce/prot_binkp.c index bc2f257..91f5263 100644 --- a/source/bforce/prot_binkp.c +++ b/source/bforce/prot_binkp.c @@ -137,6 +137,8 @@ int binkp_loop(s_binkp_state *bstate) { return PRC_ERROR; } writebuf[1] = block_length&0xff; + if (bstate->mode==bmode_transfer && bstate->remote_data->options&BINKP_OPT_CRYPT) + encrypt_buf(writebuf, have_to_write, bstate->remote_data->keys_out); } if (m==2 || m==3) { DEB((D_24554, "no more to send")); @@ -204,6 +206,8 @@ int binkp_loop(s_binkp_state *bstate) { log("read: remote socket shutdown"); return PRC_REMOTEABORTED; } + if (bstate->mode==bmode_transfer && bstate->remote_data->options & BINKP_OPT_CRYPT) + decrypt_buf(readbuf+read_pos, n, bstate->remote_data->keys_in); DEB((D_24554, "got %d bytes", n)); want_read -= n; read_pos += n; @@ -266,6 +270,11 @@ int binkp_loop(s_binkp_state *bstate) { int binkp_outgoing(s_binkp_sysinfo *local_data, s_binkp_sysinfo *remote_data) { + char *p; + init_keys(remote_data->keys_out, local_data->passwd ? local_data->passwd : "-"); + init_keys(remote_data->keys_in, "-"); + for (p=local_data->passwd ? local_data->passwd : "-"; *p; p++) + update_keys(remote_data->keys_in, (int)*p); s_binkp_state s; s.mode = bmode_outgoing_handshake; s.local_data = local_data; @@ -399,7 +408,7 @@ case 6: case 7: if (bstate->mode==bmode_outgoing_handshake) { buf[0]=BPMSG_NUL; - strcpy(buf+1, "OPT MB"); + strcpy(buf+1, "OPT MB CRYPT"); if (!nodelist_checkflag (state.node.flags, "NR")) strcat(buf+1, " NR"); // ND is too complicated and have unclear gain @@ -506,6 +515,15 @@ case 4: if (bstate->mode==bmode_incoming_handshake) { DEB((D_24554, "incoming handshake is complete")); bstate->complete = true; + char *p; + char pbuf[32]; + for (i=0;iremote_data->keys_in, pbuf?pbuf:"-"); + init_keys(bstate->remote_data->keys_out, "-"); + for (p=pbuf?pbuf:"-"; *p; p++) + update_keys(bstate->remote_data->keys_out, (int)*p); + } } else { DEB((D_24554, "outgoing handshake: everything is sent")); diff --git a/source/bforce/prot_binkp_crypt.c b/source/bforce/prot_binkp_crypt.c new file mode 100644 index 0000000..950c3f2 --- /dev/null +++ b/source/bforce/prot_binkp_crypt.c @@ -0,0 +1,148 @@ +/* + * crypt.c -- crypt binkp traffic + * + * crypt.c is a part of binkd project + * + * Copyright (c) 1990-2000 Info-ZIP. + * Copyright (C) 2001 Pavel Gulchouck 2:463/68 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. See COPYING. + * + * This encryption code is a direct transcription of the algorithm from + * Roger Schlafly. + */ +/* + * $Id: crypt.c,v 2.4 2005/10/10 15:44:24 stas Exp $ + * + * $Log: crypt.c,v $ + * Revision 2.4 2005/10/10 15:44:24 stas + * Move CRC32's define into crypt.h + * + * Revision 2.3 2001/02/21 06:25:21 gul + * changed crlf to cr in the source file + * + * Revision 2.2 2001/02/20 12:01:50 gul + * rename encrypt to encrypt_buf to avoid conflict with unistd.h + * + * Revision 2.1 2001/02/15 16:05:59 gul + * crypt bugfix + * + * Revision 2.0 2001/02/15 11:02:16 gul + * Added crypt traffic possibility + * + * + */ + +#include "includes.h" +#include "session.h" +#include "prot_common.h" +#include "prot_binkp.h" + +unsigned long crc_32_tab[256] = { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL +}; + +int update_keys (unsigned long keys[3], int c) +{ + int keyshift; + + keys[0] = CRC32(keys[0], c); + keys[1] += keys[0] & 0xff; + keys[1] = keys[1] * 134775813L + 1; + keyshift = (int)(keys[1] >> 24); + keys[2] = CRC32(keys[2], keyshift); + return c; +} + +void init_keys (unsigned long keys[3], const char *passwd) +{ + keys[0] = 305419896L; + keys[1] = 591751049L; + keys[2] = 878082192L; + while (*passwd) + { + update_keys(keys, (int)*passwd); + passwd++; + } +} + +int decrypt_byte (unsigned long keys[3]) +{ + unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an + * unpredictable manner on 16-bit systems; not a problem + * with any known compiler so far, though */ + + temp = ((unsigned)keys[2] & 0xffff) | 2; + return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); +} + +void decrypt_buf (char *buf, unsigned int bufsize, unsigned long keys[3]) +{ + while (bufsize--) + update_keys(keys, *buf++ ^= decrypt_byte(keys)); +} + +void encrypt_buf (char *buf, unsigned int bufsize, unsigned long keys[3]) +{ + int t; + while (bufsize--) + { + t=decrypt_byte(keys); + update_keys(keys, *buf); + *buf++ ^= t; + } +} diff --git a/source/bforce/prot_binkp_misc.c b/source/bforce/prot_binkp_misc.c index 585dd4e..aa71ea2 100644 --- a/source/bforce/prot_binkp_misc.c +++ b/source/bforce/prot_binkp_misc.c @@ -140,6 +140,7 @@ void binkp_log_options(s_binkp_sysinfo *remote) { if (remote->options & BINKP_OPT_MB) log ("We are in MB mode."); if (remote->options & BINKP_OPT_NR) log ("We are in NR mode."); + if (remote->options & BINKP_OPT_CRYPT) log ("We are in CRYPT mode."); } /***************************************************************************** @@ -310,6 +311,9 @@ void binkp_parse_options(s_binkp_sysinfo *binkp, char *options) if( !strcmp(p, "NR") ) { binkp->options |= BINKP_OPT_NR; } else + if( !strcmp(p, "CRYPT") ) { + binkp->options |= BINKP_OPT_CRYPT; + } else if( !strcmp(p, "MB") ) binkp->options |= BINKP_OPT_MB; else if( !strcmp(p, "MPWD") ) diff --git a/source/include/config.h b/source/include/config.h index bd0eafe..1ba0e68 100644 --- a/source/include/config.h +++ b/source/include/config.h @@ -61,7 +61,7 @@ #define BFORCE_LOCK_DIR "/var/lock/" /* Do you want to use syslog? */ -#define USE_SYSLOG 1 +/* #undef USE_SYSLOG */ /* Netspool */ #define NETSPOOL 1 diff --git a/source/include/prot_binkp.h b/source/include/prot_binkp.h index e44c487..51d44ce 100644 --- a/source/include/prot_binkp.h +++ b/source/include/prot_binkp.h @@ -53,6 +53,7 @@ #define BINKP_OPT_MD5 0x08 /* CRAM-MD5 authentication */ #define BINKP_OPT_SHA1 0x10 /* CRAM-SHA1 authentication */ #define BINKP_OPT_DES 0x20 /* CRAM-DES authentication */ +#define BINKP_OPT_CRYPT 0x40 /* CRYPT support */ typedef enum binkp_mode { bmode_failoff, @@ -85,6 +86,8 @@ typedef struct { bool has_TRF; int TRF_PKT; int TRF_other; + unsigned long keys_out[3]; /* Encription keys for outbound */ + unsigned long keys_in[3]; /* Encription keys for inbound */ } s_binkp_sysinfo; @@ -180,5 +183,13 @@ int binkp_remote_traffic(s_handshake_protocol *THIS, s_traffic *dest); /* prot_binkp_api.c */ extern s_handshake_protocol handshake_protocol_binkp; +#define CRC32(c, b) (crc_32_tab[((int)(c) ^ (b)) & 0xff] ^ ((c) >> 8)) +extern unsigned long crc_32_tab[256]; + +int update_keys (unsigned long keys[3], int c); +void init_keys (unsigned long keys[3], const char *passwd); +int decrypt_byte (unsigned long keys[3]); +void decrypt_buf (char *buf, unsigned int bufsize, unsigned long keys[3]); +void encrypt_buf (char *buf, unsigned int bufsize, unsigned long keys[3]); #endif /* _P_BINKP_H_ */