sf_attribute_table.c

著名的入侵检测系统snort的最新版本的源码

# 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)					\
    do									\
      {									\
	YYSIZE_T yynewbytes;						\
	YYCOPY (&yyptr->Stack, Stack, yysize);				\
	Stack = &yyptr->Stack;						\
	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
	yyptr += yynewbytes / sizeof (*yyptr);				\
      }									\
    while (YYID (0))

#endif

/* YYFINAL -- State number of the termination state.  */
#define YYFINAL  8
/* YYLAST -- Last index in YYTABLE.  */
#define YYLAST   133

/* YYNTOKENS -- Number of terminals.  */
#define YYNTOKENS  59
/* YYNNTS -- Number of nonterminals.  */
#define YYNNTS  54
/* YYNRULES -- Number of rules.  */
#define YYNRULES  82
/* YYNRULES -- Number of states.  */
#define YYNSTATES  151

/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
#define YYUNDEFTOK  2
#define YYMAXUTOK   313

#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,
      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
      55,    56,    57,    58
};

#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,    10,    14,    18,    19,    22,    26,
      28,    30,    33,    37,    41,    45,    46,    49,    53,    55,
      57,    62,    66,    70,    73,    77,    81,    83,    86,    88,
      90,    92,    94,    96,   100,   104,   108,   112,   116,   118,
     121,   124,   126,   129,   131,   135,   139,   143,   147,   151,
     153,   155,   156,   159,   163,   165,   167,   169,   172,   176,
     180,   184,   188,   192,   196,   200,   204,   208,   212,   217,
     221,   225,   227,   229,   230,   233,   237,   239,   241,   243,
     246,   248,   251
};

/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
static const yytype_int8 yyrhs[] =
{
      60,     0,    -1,    61,    -1,     5,    62,    70,     6,    -1,
       5,    70,     6,    -1,     7,    63,     8,    -1,    -1,    64,
      63,    -1,    65,    67,    66,    -1,     9,    -1,    10,    -1,
      69,    68,    -1,    13,    21,    14,    -1,    11,    22,    12,
      -1,    15,    71,    16,    -1,    -1,    71,    72,    -1,    73,
      75,    74,    -1,    17,    -1,    18,    -1,    76,    77,    90,
     104,    -1,    76,    77,   104,    -1,    76,    77,    90,    -1,
      76,    77,    -1,    19,    21,    20,    -1,    25,    78,    26,
      -1,    79,    -1,    78,    79,    -1,    80,    -1,    81,    -1,
      82,    -1,    84,    -1,    83,    -1,    33,    85,    34,    -1,
      35,    85,    36,    -1,    37,    85,    38,    -1,    39,    21,
      40,    -1,    41,    21,    42,    -1,    86,    -1,    86,    89,
      -1,    87,    89,    -1,    87,    -1,    88,    89,    -1,    88,
      -1,    27,    21,    28,    -1,    27,    22,    28,    -1,    29,
      22,    30,    -1,    31,    22,    32,    -1,    91,    93,    92,
      -1,    43,    -1,    44,    -1,    -1,    94,    93,    -1,    95,
      97,    96,    -1,    45,    -1,    46,    -1,    98,    -1,    98,
     102,    -1,    99,   100,   101,    -1,    99,   101,   100,    -1,
     100,    99,   101,    -1,   100,   101,    99,    -1,   101,   100,
      99,    -1,   101,    99,   100,    -1,    51,    85,    52,    -1,
      55,    85,    56,    -1,    53,    85,    54,    -1,    57,    85,
      58,    -1,    57,    85,   103,    58,    -1,    37,    85,    38,
      -1,   105,   107,   106,    -1,    47,    -1,    48,    -1,    -1,
     108,   107,    -1,   109,   111,   110,    -1,    49,    -1,    50,
      -1,   112,    -1,   112,   102,    -1,   100,    -1,    99,   100,
      -1,   100,    99,    -1
};

/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
static const yytype_uint16 yyrline[] =
{
       0,   138,   138,   144,   149,   156,   162,   165,   168,   176,
     179,   182,   189,   196,   204,   210,   213,   216,   226,   233,
     236,   241,   246,   251,   258,   269,   271,   271,   273,   273,
     273,   273,   273,   276,   284,   292,   300,   308,   316,   322,
     328,   334,   340,   360,   382,   388,   394,   401,   408,   414,
     421,   427,   430,   436,   444,   451,   457,   461,   467,   472,
     477,   482,   487,   492,   499,   507,   515,   523,   530,   539,
     547,   553,   560,   566,   569,   575,   583,   590,   596,   600,
     606,   611,   616
};
#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", "SF_AT_COMMENT", "SF_AT_WHITESPACE",
  "SF_START_SNORT_ATTRIBUTES", "SF_END_SNORT_ATTRIBUTES",
  "SF_AT_START_MAP_TABLE", "SF_AT_END_MAP_TABLE", "SF_AT_START_ENTRY",
  "SF_AT_END_ENTRY", "SF_AT_START_ENTRY_ID", "SF_AT_END_ENTRY_ID",
  "SF_AT_START_ENTRY_VALUE", "SF_AT_END_ENTRY_VALUE",
  "SF_AT_START_ATTRIBUTE_TABLE", "SF_AT_END_ATTRIBUTE_TABLE",
  "SF_AT_START_HOST", "SF_AT_END_HOST", "SF_AT_START_HOST_IP",
  "SF_AT_END_HOST_IP", "SF_AT_STRING", "SF_AT_NUMERIC", "SF_AT_IPv6",
  "SF_AT_IPv6Cidr", "SF_AT_START_OS", "SF_AT_END_OS",
  "SF_AT_START_ATTRIBUTE_VALUE", "SF_AT_END_ATTRIBUTE_VALUE",
  "SF_AT_START_ATTRIBUTE_ID", "SF_AT_END_ATTRIBUTE_ID",
  "SF_AT_START_CONFIDENCE", "SF_AT_END_CONFIDENCE", "SF_AT_START_NAME",
  "SF_AT_END_NAME", "SF_AT_START_VENDOR", "SF_AT_END_VENDOR",
  "SF_AT_START_VERSION", "SF_AT_END_VERSION", "SF_AT_START_FRAG_POLICY",
  "SF_AT_END_FRAG_POLICY", "SF_AT_START_STREAM_POLICY",
  "SF_AT_END_STREAM_POLICY", "SF_AT_START_SERVICES", "SF_AT_END_SERVICES",
  "SF_AT_START_SERVICE", "SF_AT_END_SERVICE", "SF_AT_START_CLIENTS",
  "SF_AT_END_CLIENTS", "SF_AT_START_CLIENT", "SF_AT_END_CLIENT",
  "SF_AT_START_IPPROTO", "SF_AT_END_IPPROTO", "SF_AT_START_PORT",
  "SF_AT_END_PORT", "SF_AT_START_PROTOCOL", "SF_AT_END_PROTOCOL",
  "SF_AT_START_APPLICATION", "SF_AT_END_APPLICATION", "$accept",
  "AttributeGrammar", "SnortAttributes", "MappingTable",
  "ListOfMapEntries", "MapEntry", "MapEntryStart", "MapEntryEnd",
  "MapEntryData", "MapValue", "MapId", "AttributeTable", "ListOfHosts",
  "HostEntry", "HostEntryStart", "HostEntryEnd", "HostEntryData", "IpCidr",
  "HostOS", "OSAttributes", "OSAttribute", "OSName", "OSVendor",
  "OSVersion", "OSFragPolicy", "OSStreamPolicy", "AttributeInfo",
  "AttributeValueString", "AttributeValueNumber", "AttributeId",
  "AttributeConfidence", "ServiceList", "ServiceListStart",
  "ServiceListEnd", "ServiceListData", "Service", "ServiceStart",
  "ServiceEnd", "ServiceData", "ServiceDataRequired", "IPProtocol",
  "Protocol", "Port", "Application", "Version", "ClientList",
  "ClientListStart", "ClientListEnd", "ClientListData", "Client",
  "ClientStart", "ClientEnd", "ClientData", "ClientDataRequired", 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,   290,   291,   292,   293,   294,
     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
     305,   306,   307,   308,   309,   310,   311,   312,   313
};
# endif

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const yytype_uint8 yyr1[] =
{
       0,    59,    60,    61,    61,    62,    63,    63,    64,    65,
      66,    67,    68,    69,    70,    71,    71,    72,    73,    74,
      75,    75,    75,    75,    76,    77,    78,    78,    79,    79,
      79,    79,    79,    80,    81,    82,    83,    84,    85,    85,
      85,    85,    85,    85,    86,    87,    88,    89,    90,    91,
      92,    93,    93,    94,    95,    96,    97,    97,    98,    98,
      98,    98,    98,    98,    99,   100,   101,   102,   102,   103,
     104,   105,   106,   107,   107,   108,   109,   110,   111,   111,
     112,   112,   112
};

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
static const yytype_uint8 yyr2[] =
{
       0,     2,     1,     4,     3,     3,     0,     2,     3,     1,
       1,     2,     3,     3,     3,     0,     2,     3,     1,     1,
       4,     3,     3,     2,     3,     3,     1,     2,     1,     1,
       1,     1,     1,     3,     3,     3,     3,     3,     1,     2,
       2,     1,     2,     1,     3,     3,     3,     3,     3,     1,
       1,     0,     2,     3,     1,     1,     1,     2,     3,     3,
       3,     3,     3,     3,     3,     3,     3,     3,     4,     3,
       3,     1,     1,     0,     2,     3,     1,     1,     1,     2,
       1,     2,     2
};

/* 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,     0,     0,     2,     6,    15,     0,     0,     1,     9,
       0,     6,     0,     0,     0,     4,     5,     7,     0,     0,
       0,    14,    18,    16,     0,     3,     0,    10,     8,     0,
      11,     0,     0,     0,    13,     0,     0,    19,    17,     0,
      23,    12,    24,     0,     0,     0,     0,     0,     0,    26,
      28,    29,    30,    32,    31,    49,    71,    22,    51,    21,
      73,     0,     0,     0,    38,    41,    43,     0,     0,     0,
       0,    25,    27,    20,    54,     0,    51,     0,    76,     0,
      73,     0,     0,     0,     0,    33,     0,    39,    40,    42,
      34,    35,    36,    37,    50,    48,    52,     0,     0,     0,
       0,    56,     0,     0,     0,    72,    70,    74,     0,    80,
       0,    78,    44,    45,    46,     0,     0,     0,     0,    55,
      53,     0,    57,     0,     0,     0,     0,     0,     0,    81,
      82,    77,    75,    79,    47,    64,    66,    65,     0,    58,
      59,    60,    61,    63,    62,     0,    67,     0,     0,    68,
      69
};

/* YYDEFGOTO[NTERM-NUM].  */
static const yytype_int16 yydefgoto[] =
{
      -1,     2,     3,     6,    10,    11,    12,    28,    19,    30,
      20,     7,    13,    23,    24,    38,    32,    33,    40,    48,
      49,    50,    51,    52,    53,    54,    63,    64,    65,    66,
      87,    57,    58,    95,    75,    76,    77,   120,   100,   101,
     102,   103,   104,   122,   147,    59,    60,   106,    79,    80,
      81,   132,   110,   111
};

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   STATE-NUM.  */
#define YYPACT_NINF -97
static const yytype_int8 yypact[] =
{
      -2,    26,    22,   -97,    28,   -97,    27,    54,   -97,   -97,
      38,    28,    50,    40,    56,   -97,   -97,   -97,    41,    55,
      51,   -97,   -97,   -97,    47,   -97,    57,   -97,   -97,    46,
     -97,    49,    53,    43,   -97,    58,    59,   -97,   -97,   -21,
      -8,   -97,   -97,    -6,    -6,    -6,    52,    60,   -22,   -97,
     -97,   -97,   -97,   -97,   -97,   -97,   -97,    29,    30,   -97,
      25,   -13,    61,    44,    62,    62,    62,    48,    42,    45,
      63,   -97,   -97,   -97,   -97,    64,    30,   -17,   -97,    34,
      25,   -11,    66,    67,    68,   -97,    65,   -97,   -97,   -97,
     -97,   -97,   -97,   -97,   -97,   -97,   -97,    -6,    -6,    -6,
      69,    31,   -10,    -1,   -11,   -97,   -97,   -97,    35,    70,
      36,    31,   -97,   -97,   -97,    71,    37,    72,    73,   -97,
     -97,    -6,   -97,    39,    35,    39,    70,    35,    70,   -97,
     -97,   -97,   -97,   -97,   -97,   -97,   -97,   -97,   -27,   -97,
     -97,   -97,   -97,   -97,   -97,    -6,   -97,    33,    74,   -97,
     -97
};

/* YYPGOTO[NTERM-NUM].  */
static const yytype_int8 yypgoto[] =
{
     -97,   -97,   -97,   -97,    85,   -97,   -97,   -97,   -97,   -97,
     -97,    91,   -97,   -97,   -97,   -97,   -97,   -97,   -97,   -97,
      75,   -97,   -97,   -97,   -97,   -97,   -44,   -97,   -97,   -97,
      -7,   -97,   -97,   -97,    23,   -97,   -97,   -97,   -97,   -97,
     -79,   -76,   -96,    -9,   -97,    76,   -97,   -97,    20,   -97,
     -97,   -97,   -97,   -97
};

/* 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[] =
{
      67,    68,   108,     1,    71,   109,   124,   126,    82,    83,
     145,    43,    43,    44,    44,    45,    45,    46,    46,    47,
      47,    61,     8,    62,   125,   127,   123,   139,   128,   141,
     130,   146,   129,     4,    97,    55,    98,     9,    99,    56,
      97,     5,     5,    98,    99,    99,    16,   142,   140,   144,
      97,   143,    98,   116,   117,   118,    21,    22,    88,    89,
      15,    18,    25,    26,    29,    27,    31,    35,    39,    34,
      36,    37,    41,    69,    78,    74,    56,   138,    85,    42,
      91,    70,   105,    84,    90,    92,   131,   115,   121,   135,
      99,   149,    98,    86,   112,   113,    17,    14,   114,    96,
     107,   148,   133,   134,     0,    93,     0,     0,    94,     0,
       0,     0,   150,     0,     0,   119,     0,     0,     0,     0,
       0,    97,     0,    72,     0,     0,   136,     0,     0,   137,
       0,     0,     0,    73
};

static const yytype_int16 yycheck[] =
{
      44,    45,    81,     5,    26,    81,   102,   103,    21,    22,
      37,    33,    33,    35,    35,    37,    37,    39,    39,    41,
      41,    27,     0,    29,   103,   104,   102,   123,   104,   125,
     109,    58,   108,     7,    51,    43,    53,     9,    55,    47,
      51,    15,    15,    53,    55,    55,     8,   126,   124,   128,
      51,   127,    53,    97,    98,    99,    16,    17,    65,    66,
       6,    11,     6,    22,    13,    10,    19,    21,    25,    12,
      21,    18,    14,    21,    49,    45,    47,   121,    34,    20,
      38,    21,    48,    22,    36,    40,    50,    22,    57,    52,
      55,    58,    53,    31,    28,    28,    11,     6,    30,    76,
      80,   145,   111,    32,    -1,    42,    -1,    -1,    44,    -1,
      -1,    -1,    38,    -1,    -1,    46,    -1,    -1,    -1,    -1,
      -1,    51,    -1,    48,    -1,    -1,    54,    -1,    -1,    56,
      -1,    -1,    -1,    57
};

/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
   symbol of state STATE-NUM.  */
static const yytype_uint8 yystos[] =
{
       0,     5,    60,    61,     7,    15,    62,    70,     0,     9,
      63,    64,    65,    71,    70,     6,     8,    63,    11,    67,
      69,    16,    17,    72,    73,     6,    22,    10,    66,    13,
      68,    19,    75,    76,    12,    21,    21,    18,    74,    25,
      77,    14,    20,    33,    35,    37,    39,    41,    78,    79,
      80,    81,    82,    83,    84,    43,    47,    90,    91,   104,
     105,    27,    29,    85,    86,    87,    88,    85,    85,    21,
      21,    26,    79,   104,    45,    93,    94,    95,    49,   107,
     108,   109,    21,    22,    22,    34,    31,    89,    89,    89,
      36,    38,    40,    42,    44,    92,    93,    51,    53,    55,
      97,    98,    99,   100,   101,    48,   106,   107,    99,   100,
     111,   112,    28,    28,    30,    22,    85,    85,    85,    46,
      96,    57,   102,   100,   101,    99,   101,    99,   100,   100,
      99,    50,   110,   102,    32,    52,    54,    56,    85,   101,
     100,   101,    99,   100,    99,    37,    58,   103,    85,    58,
      38
};

#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.  */

#define YYFAIL		goto yyerrlab

#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


/* YY_LOCATION_PRINT -- Print the location on the stream.