From ecd273d59ab89c70355504b89445563e9a987812 Mon Sep 17 00:00:00 2001 From: Pier-Hugues Pellerin Date: Thu, 5 Mar 2020 08:27:52 -0500 Subject: [PATCH] Cherry-pick #10760 to 6.8: (#15980) Adding Cisco support for the Syslog parser * Adding Cisco support for the Syslog parser Add support for the "sequence" number in the log format send by Cisco switch devices. Fixes: #10654, #15979 (cherry picked from commit dd92b6f887c18c40932969d9430be9d54d7f6903) Co-authored-by: Pier-Hugues Pellerin --- CHANGELOG.next.asciidoc | 1 + filebeat/_meta/fields.common.yml | 6 + filebeat/docs/fields.asciidoc | 12 + filebeat/include/fields.go | 2 +- filebeat/input/syslog/event.go | 13 + filebeat/input/syslog/input.go | 5 + filebeat/input/syslog/input_test.go | 26 + filebeat/input/syslog/parser.go | 2259 +++++++++++++++-------- filebeat/input/syslog/parser.rl | 27 +- filebeat/input/syslog/parser_test.go | 109 ++ filebeat/input/syslog/syslog_rfc3164.rl | 11 +- 11 files changed, 1651 insertions(+), 820 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 3cdb3cf4cabf..8905f4ffc4c4 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -38,6 +38,7 @@ https://github.com/elastic/beats/compare/v6.8.0...6.8.1[Check the HEAD diff] *Filebeat* +- Add support for Cisco syslog format used by their switch. {pull}10760[10760] *Heartbeat* diff --git a/filebeat/_meta/fields.common.yml b/filebeat/_meta/fields.common.yml index 08b7d453eb38..9960a87d451a 100644 --- a/filebeat/_meta/fields.common.yml +++ b/filebeat/_meta/fields.common.yml @@ -60,6 +60,12 @@ description: > The Filebeat dataset that generated this event. + - name: event.sequence + type: long + required: false + description: > + The sequence number of this event. + - name: syslog.facility type: long required: false diff --git a/filebeat/docs/fields.asciidoc b/filebeat/docs/fields.asciidoc index 9cd6df2fb743..947f76d45655 100644 --- a/filebeat/docs/fields.asciidoc +++ b/filebeat/docs/fields.asciidoc @@ -3299,6 +3299,18 @@ The Filebeat fileset that generated this event. The Filebeat dataset that generated this event. +-- + +*`event.sequence`*:: ++ +-- +type: long + +required: False + +The sequence number of this event. + + -- *`syslog.facility`*:: diff --git a/filebeat/include/fields.go b/filebeat/include/fields.go index 707d14ecccee..dd4b7174fdbb 100644 --- a/filebeat/include/fields.go +++ b/filebeat/include/fields.go @@ -31,5 +31,5 @@ func init() { // Asset returns asset data func Asset() string { - return "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" + return "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" } diff --git a/filebeat/input/syslog/event.go b/filebeat/input/syslog/event.go index 30c17bdef162..c5eccd6ea67f 100644 --- a/filebeat/input/syslog/event.go +++ b/filebeat/input/syslog/event.go @@ -71,6 +71,7 @@ type event struct { nanosecond int year int loc *time.Location + sequence int } // newEvent() return a new event. @@ -84,6 +85,7 @@ func newEvent() *event { minute: -1, second: -1, year: time.Now().Year(), + sequence: -1, } } @@ -269,6 +271,17 @@ func (s *event) HasPid() bool { return s.pid > 0 } +// SetSequence set the sequence number for this event. +func (s *event) SetSequence(b []byte) { + s.sequence = bytesToInt(b) +} + +// Sequence returns the sequence number of the event when defined, +// otherwise return -1. +func (s *event) Sequence() int { + return s.sequence +} + // SetNanoSecond sets the nanosecond. func (s *event) SetNanosecond(b []byte) { // We assume that we receive a byte array representing a nanosecond, this might not be diff --git a/filebeat/input/syslog/input.go b/filebeat/input/syslog/input.go index 1aeac3975216..7eef15e45d79 100644 --- a/filebeat/input/syslog/input.go +++ b/filebeat/input/syslog/input.go @@ -37,6 +37,7 @@ import ( // Parser is generated from a ragel state machine using the following command: //go:generate ragel -Z -G2 parser.rl -o parser.go +//go:generate go fmt parser.go // Severity and Facility are derived from the priority, theses are the human readable terms // defined in https://tools.ietf.org/html/rfc3164#section-4.1.1. @@ -251,6 +252,10 @@ func createEvent(ev *event, metadata inputsource.NetworkMetadata, timezone *time f["event"] = event f["process"] = process + if ev.Sequence() != -1 { + f["event.sequence"] = ev.Sequence() + } + return &beat.Event{ Timestamp: ev.Timestamp(timezone), Meta: common.MapStr{ diff --git a/filebeat/input/syslog/input_test.go b/filebeat/input/syslog/input_test.go index 939d06150cdd..e1857464803d 100644 --- a/filebeat/input/syslog/input_test.go +++ b/filebeat/input/syslog/input_test.go @@ -176,6 +176,32 @@ func TestProgram(t *testing.T) { }) } +func TestSequence(t *testing.T) { + t.Run("is set", func(t *testing.T) { + e := newEvent() + e.SetMessage([]byte("hello world")) + e.SetProgram([]byte("sudo")) + e.SetSequence([]byte("123")) + m := dummyMetadata() + event := createEvent(e, m, time.Local, logp.NewLogger("syslog")) + v, err := event.GetValue("event.sequence") + if !assert.NoError(t, err) { + return + } + assert.Equal(t, v, 123) + }) + + t.Run("is not set", func(t *testing.T) { + e := newEvent() + e.SetMessage([]byte("hello world")) + m := dummyMetadata() + event := createEvent(e, m, time.Local, logp.NewLogger("syslog")) + + _, err := event.GetValue("event.sequence") + assert.Error(t, err) + }) +} + func dummyMetadata() inputsource.NetworkMetadata { ip := "127.0.0.1" parsedIP := net.ParseIP(ip) diff --git a/filebeat/input/syslog/parser.go b/filebeat/input/syslog/parser.go index 7ffe5f73a033..16754a766f35 100644 --- a/filebeat/input/syslog/parser.go +++ b/filebeat/input/syslog/parser.go @@ -22,28 +22,30 @@ package syslog //line parser.go:8 const syslog_start int = 0 -const syslog_first_final int = 1 +const syslog_first_final int = 2 const syslog_error int = -1 const syslog_en_main int = 0 +const syslog_en_catch_all int = 1 //line parser.rl:9 +var ( + noDuplicates = []byte{'-', '.'} +) -// syslog -//<34>Oct 11 22:14:15 wopr su: 'su root' failed for foobar -//<13>Feb 5 17:32:18 10.0.0.99 Use the quad dmg. +// Parse parses Syslog events. func Parse(data []byte, event *event) { var p, cs int pe := len(data) tok := 0 eof := len(data) -//line parser.go:28 +//line parser.go:31 { cs = syslog_start } -//line parser.go:33 +//line parser.go:36 { if (p) == (pe) { goto _test_eof @@ -51,8 +53,6 @@ func Parse(data []byte, event *event) { switch cs { case 0: goto st_case_0 - case 1: - goto st_case_1 case 2: goto st_case_2 case 3: @@ -263,6 +263,36 @@ func Parse(data []byte, event *event) { goto st_case_105 case 106: goto st_case_106 + case 107: + goto st_case_107 + case 108: + goto st_case_108 + case 109: + goto st_case_109 + case 110: + goto st_case_110 + case 111: + goto st_case_111 + case 112: + goto st_case_112 + case 113: + goto st_case_113 + case 114: + goto st_case_114 + case 115: + goto st_case_115 + case 116: + goto st_case_116 + case 117: + goto st_case_117 + case 118: + goto st_case_118 + case 119: + goto st_case_119 + case 1: + goto st_case_1 + case 120: + goto st_case_120 } goto st_out st_case_0: @@ -291,19 +321,15 @@ func Parse(data []byte, event *event) { } goto tr0 tr0: -//line parser.rl:20 +//line parser.rl:22 tok = p - goto st1 - st1: - if (p)++; (p) == (pe) { - goto _test_eof1 - } - st_case_1: -//line parser.go:291 - goto st1 - tr1: -//line parser.rl:20 + goto st2 + tr75: +//line parser.rl:97 + event.SetSequence(data[tok:p]) + +//line parser.rl:22 tok = p goto st2 @@ -312,56 +338,68 @@ func Parse(data []byte, event *event) { goto _test_eof2 } st_case_2: -//line parser.go:304 - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st3 - } - goto st1 +//line parser.go:332 + goto st2 + tr1: +//line parser.rl:22 + tok = p + + goto st3 st3: if (p)++; (p) == (pe) { goto _test_eof3 } st_case_3: +//line parser.go:345 + if data[(p)] == 58 { + goto st48 + } if 48 <= data[(p)] && data[(p)] <= 57 { goto st4 } - goto st1 + goto st2 st4: if (p)++; (p) == (pe) { goto _test_eof4 } st_case_4: + if data[(p)] == 58 { + goto st48 + } if 48 <= data[(p)] && data[(p)] <= 57 { goto st5 } - goto st1 + goto st2 st5: if (p)++; (p) == (pe) { goto _test_eof5 } st_case_5: - if data[(p)] == 45 { - goto tr15 + if data[(p)] == 58 { + goto st48 } - goto st1 - tr15: -//line parser.rl:36 - event.SetYear(data[tok:p]) - - goto st6 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st6 + } + goto st2 st6: if (p)++; (p) == (pe) { goto _test_eof6 } st_case_6: -//line parser.go:347 + switch data[(p)] { + case 45: + goto tr17 + case 58: + goto st48 + } if 48 <= data[(p)] && data[(p)] <= 57 { - goto tr16 + goto st47 } - goto st1 - tr16: -//line parser.rl:20 - tok = p + goto st2 + tr17: +//line parser.rl:38 + event.SetYear(data[tok:p]) goto st7 st7: @@ -369,38 +407,38 @@ func Parse(data []byte, event *event) { goto _test_eof7 } st_case_7: -//line parser.go:363 +//line parser.go:403 if 48 <= data[(p)] && data[(p)] <= 57 { - goto st8 + goto tr19 } - goto st1 + goto st2 + tr19: +//line parser.rl:22 + tok = p + + goto st8 st8: if (p)++; (p) == (pe) { goto _test_eof8 } st_case_8: - if data[(p)] == 45 { - goto tr18 +//line parser.go:419 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st9 } - goto st1 - tr18: -//line parser.rl:40 - event.SetMonthNumeric(data[tok:p]) - - goto st9 + goto st2 st9: if (p)++; (p) == (pe) { goto _test_eof9 } st_case_9: -//line parser.go:388 - if 48 <= data[(p)] && data[(p)] <= 51 { - goto tr19 + if data[(p)] == 45 { + goto tr21 } - goto st1 - tr19: -//line parser.rl:20 - tok = p + goto st2 + tr21: +//line parser.rl:42 + event.SetMonthNumeric(data[tok:p]) goto st10 st10: @@ -408,88 +446,88 @@ func Parse(data []byte, event *event) { goto _test_eof10 } st_case_10: -//line parser.go:404 - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st11 +//line parser.go:444 + if 48 <= data[(p)] && data[(p)] <= 51 { + goto tr22 } - goto st1 + goto st2 + tr22: +//line parser.rl:22 + tok = p + + goto st11 st11: if (p)++; (p) == (pe) { goto _test_eof11 } st_case_11: +//line parser.go:460 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st12 + } + goto st2 + st12: + if (p)++; (p) == (pe) { + goto _test_eof12 + } + st_case_12: switch data[(p)] { case 32: - goto tr21 + goto tr24 case 84: - goto tr21 + goto tr24 case 116: - goto tr21 + goto tr24 } if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr21 + goto tr24 } - goto st1 - tr21: -//line parser.rl:44 + goto st2 + tr24: +//line parser.rl:46 event.SetDay(data[tok:p]) - goto st12 - st12: + goto st13 + st13: if (p)++; (p) == (pe) { - goto _test_eof12 + goto _test_eof13 } - st_case_12: -//line parser.go:437 + st_case_13: +//line parser.go:493 if data[(p)] == 50 { - goto tr23 + goto tr26 } if 48 <= data[(p)] && data[(p)] <= 49 { - goto tr22 + goto tr25 } - goto st1 - tr22: -//line parser.rl:20 + goto st2 + tr25: +//line parser.rl:22 tok = p - goto st13 - st13: - if (p)++; (p) == (pe) { - goto _test_eof13 - } - st_case_13: -//line parser.go:456 - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st14 - } - goto st1 + goto st14 st14: if (p)++; (p) == (pe) { goto _test_eof14 } st_case_14: - if data[(p)] == 58 { - goto tr25 +//line parser.go:512 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st15 } - goto st1 - tr25: -//line parser.rl:48 - event.SetHour(data[tok:p]) - - goto st15 + goto st2 st15: if (p)++; (p) == (pe) { goto _test_eof15 } st_case_15: -//line parser.go:481 - if 48 <= data[(p)] && data[(p)] <= 53 { - goto tr26 + if data[(p)] == 58 { + goto tr28 } - goto st1 - tr26: -//line parser.rl:20 - tok = p + goto st2 + tr28: +//line parser.rl:50 + event.SetHour(data[tok:p]) goto st16 st16: @@ -497,38 +535,38 @@ func Parse(data []byte, event *event) { goto _test_eof16 } st_case_16: -//line parser.go:497 - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st17 +//line parser.go:537 + if 48 <= data[(p)] && data[(p)] <= 53 { + goto tr29 } - goto st1 + goto st2 + tr29: +//line parser.rl:22 + tok = p + + goto st17 st17: if (p)++; (p) == (pe) { goto _test_eof17 } st_case_17: - if data[(p)] == 58 { - goto tr28 +//line parser.go:553 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st18 } - goto st1 - tr28: -//line parser.rl:52 - event.SetMinute(data[tok:p]) - - goto st18 + goto st2 st18: if (p)++; (p) == (pe) { goto _test_eof18 } st_case_18: -//line parser.go:522 - if 48 <= data[(p)] && data[(p)] <= 53 { - goto tr29 + if data[(p)] == 58 { + goto tr31 } - goto st1 - tr29: -//line parser.rl:20 - tok = p + goto st2 + tr31: +//line parser.rl:54 + event.SetMinute(data[tok:p]) goto st19 st19: @@ -536,94 +574,125 @@ func Parse(data []byte, event *event) { goto _test_eof19 } st_case_19: -//line parser.go:538 - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st20 +//line parser.go:578 + if 48 <= data[(p)] && data[(p)] <= 53 { + goto tr32 } - goto st1 + goto st2 + tr32: +//line parser.rl:22 + tok = p + + goto st20 st20: if (p)++; (p) == (pe) { goto _test_eof20 } st_case_20: +//line parser.go:594 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st21 + } + goto st2 + st21: + if (p)++; (p) == (pe) { + goto _test_eof21 + } + st_case_21: switch data[(p)] { case 32: - goto tr31 + goto tr34 case 43: - goto tr32 + goto tr35 case 45: - goto tr32 + goto tr35 case 46: - goto tr33 + goto tr36 + case 58: + goto tr37 case 90: - goto tr34 + goto tr38 case 122: - goto tr34 + goto tr38 } if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr31 + goto tr34 } - goto st1 - tr31: -//line parser.rl:56 + goto st2 + tr34: +//line parser.rl:58 event.SetSecond(data[tok:p]) - goto st21 - tr49: -//line parser.rl:76 + goto st22 + tr61: +//line parser.rl:93 event.SetTimeZone(data[tok:p]) - goto st21 - tr54: -//line parser.rl:60 + goto st22 + tr68: +//line parser.rl:62 event.SetNanosecond(data[tok:p]) - goto st21 - st21: - if (p)++; (p) == (pe) { - goto _test_eof21 - } - st_case_21: -//line parser.go:589 - switch { - case data[(p)] > 95: - if 97 <= data[(p)] && data[(p)] <= 122 { - goto tr35 - } - case data[(p)] >= 46: - goto tr35 - } - goto tr0 - tr35: -//line parser.rl:20 - tok = p - goto st22 st22: if (p)++; (p) == (pe) { goto _test_eof22 } st_case_22: -//line parser.go:610 - if data[(p)] == 32 { - goto tr36 +//line parser.go:647 + switch data[(p)] { + case 58: + goto tr41 + case 95: + goto tr39 } switch { - case data[(p)] < 46: - if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr36 + case data[(p)] < 48: + if 45 <= data[(p)] && data[(p)] <= 46 { + goto tr39 } - case data[(p)] > 95: - if 97 <= data[(p)] && data[(p)] <= 122 { - goto st22 + case data[(p)] > 57: + switch { + case data[(p)] > 90: + if 97 <= data[(p)] && data[(p)] <= 122 { + goto tr40 + } + case data[(p)] >= 65: + goto tr40 } default: - goto st22 + goto tr40 + } + goto tr0 + tr39: +//line parser.rl:22 + tok = p + +//line parser.rl:70 + if p-1 > 0 { + for _, b := range noDuplicates { + if data[p] == b && data[p-1] == b { + p = tok - 1 + { + goto st1 + } + } + } + } + + goto st23 + tr42: +//line parser.rl:70 + if p-1 > 0 { + for _, b := range noDuplicates { + if data[p] == b && data[p-1] == b { + p = tok - 1 + { + goto st1 + } + } + } } - goto st1 - tr36: -//line parser.rl:64 - event.SetHostname(data[tok:p]) goto st23 st23: @@ -631,47 +700,102 @@ func Parse(data []byte, event *event) { goto _test_eof23 } st_case_23: -//line parser.go:638 +//line parser.go:707 switch data[(p)] { - case 32: - goto tr0 - case 91: - goto tr0 - case 93: - goto tr0 + case 58: + goto tr44 + case 95: + goto tr42 } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr0 + switch { + case data[(p)] < 48: + if 45 <= data[(p)] && data[(p)] <= 46 { + goto tr42 + } + case data[(p)] > 57: + switch { + case data[(p)] > 90: + if 97 <= data[(p)] && data[(p)] <= 122 { + goto tr43 + } + case data[(p)] >= 65: + goto tr43 + } + default: + goto tr43 } - goto tr38 - tr38: -//line parser.rl:20 + goto st2 + tr40: +//line parser.rl:22 tok = p +//line parser.rl:70 + if p-1 > 0 { + for _, b := range noDuplicates { + if data[p] == b && data[p-1] == b { + p = tok - 1 + { + goto st1 + } + } + } + } + + goto st24 + tr43: +//line parser.rl:70 + if p-1 > 0 { + for _, b := range noDuplicates { + if data[p] == b && data[p-1] == b { + p = tok - 1 + { + goto st1 + } + } + } + } + goto st24 st24: if (p)++; (p) == (pe) { goto _test_eof24 } st_case_24: -//line parser.go:662 +//line parser.go:767 switch data[(p)] { case 32: - goto st1 + goto tr45 case 58: - goto tr40 - case 91: - goto tr41 - case 93: - goto st1 + goto tr46 + case 95: + goto tr42 } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto st1 + switch { + case data[(p)] < 48: + switch { + case data[(p)] > 13: + if 45 <= data[(p)] && data[(p)] <= 46 { + goto tr42 + } + case data[(p)] >= 9: + goto tr45 + } + case data[(p)] > 57: + switch { + case data[(p)] > 90: + if 97 <= data[(p)] && data[(p)] <= 122 { + goto tr43 + } + case data[(p)] >= 65: + goto tr43 + } + default: + goto tr43 } - goto st24 - tr40: -//line parser.rl:68 - event.SetProgram(data[tok:p]) + goto st2 + tr45: +//line parser.rl:81 + event.SetHostname(data[tok:p]) goto st25 st25: @@ -679,29 +803,46 @@ func Parse(data []byte, event *event) { goto _test_eof25 } st_case_25: -//line parser.go:688 +//line parser.go:810 switch data[(p)] { case 32: - goto st26 - case 58: - goto tr40 + goto tr0 case 91: - goto tr41 + goto tr0 case 93: - goto st1 + goto tr0 } if 9 <= data[(p)] && data[(p)] <= 13 { - goto st26 + goto tr0 } - goto st24 + goto tr47 + tr47: +//line parser.rl:22 + tok = p + + goto st26 st26: if (p)++; (p) == (pe) { goto _test_eof26 } st_case_26: - goto tr0 - tr41: -//line parser.rl:68 +//line parser.go:834 + switch data[(p)] { + case 32: + goto st2 + case 58: + goto tr49 + case 91: + goto tr50 + case 93: + goto st2 + } + if 9 <= data[(p)] && data[(p)] <= 13 { + goto st2 + } + goto st26 + tr49: +//line parser.rl:85 event.SetProgram(data[tok:p]) goto st27 @@ -710,32 +851,30 @@ func Parse(data []byte, event *event) { goto _test_eof27 } st_case_27: -//line parser.go:720 - if 48 <= data[(p)] && data[(p)] <= 57 { - goto tr43 +//line parser.go:860 + switch data[(p)] { + case 32: + goto st28 + case 58: + goto tr49 + case 91: + goto tr50 + case 93: + goto st2 } - goto st1 - tr43: -//line parser.rl:20 - tok = p - - goto st28 + if 9 <= data[(p)] && data[(p)] <= 13 { + goto st28 + } + goto st26 st28: if (p)++; (p) == (pe) { goto _test_eof28 } st_case_28: -//line parser.go:736 - if data[(p)] == 93 { - goto tr45 - } - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st28 - } - goto st1 - tr45: -//line parser.rl:72 - event.SetPid(data[tok:p]) + goto tr0 + tr50: +//line parser.rl:85 + event.SetProgram(data[tok:p]) goto st29 st29: @@ -743,37 +882,32 @@ func Parse(data []byte, event *event) { goto _test_eof29 } st_case_29: -//line parser.go:755 - if data[(p)] == 58 { - goto st30 +//line parser.go:892 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto tr52 } - goto st1 + goto st2 + tr52: +//line parser.rl:22 + tok = p + + goto st30 st30: if (p)++; (p) == (pe) { goto _test_eof30 } st_case_30: - if data[(p)] == 32 { - goto st26 +//line parser.go:908 + if data[(p)] == 93 { + goto tr54 } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto st26 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st30 } - goto st1 - tr32: -//line parser.rl:56 - event.SetSecond(data[tok:p]) - -//line parser.rl:20 - tok = p - - goto st31 - tr55: -//line parser.rl:60 - event.SetNanosecond(data[tok:p]) - -//line parser.rl:20 - tok = p + goto st2 + tr54: +//line parser.rl:89 + event.SetPid(data[tok:p]) goto st31 st31: @@ -781,169 +915,298 @@ func Parse(data []byte, event *event) { goto _test_eof31 } st_case_31: -//line parser.go:797 - if 48 <= data[(p)] && data[(p)] <= 57 { +//line parser.go:927 + if data[(p)] == 58 { goto st32 } - goto st1 + goto st2 st32: if (p)++; (p) == (pe) { goto _test_eof32 } st_case_32: - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st33 + if data[(p)] == 32 { + goto st28 } - goto st1 + if 9 <= data[(p)] && data[(p)] <= 13 { + goto st28 + } + goto st2 + tr46: +//line parser.rl:70 + if p-1 > 0 { + for _, b := range noDuplicates { + if data[p] == b && data[p-1] == b { + p = tok - 1 + { + goto st1 + } + } + } + } + +//line parser.rl:81 + event.SetHostname(data[tok:p]) + + goto st33 st33: if (p)++; (p) == (pe) { goto _test_eof33 } st_case_33: +//line parser.go:966 switch data[(p)] { case 32: - goto tr49 + goto st25 case 58: - goto st36 + goto tr57 + case 95: + goto tr42 } switch { - case data[(p)] > 13: - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st34 + case data[(p)] < 48: + switch { + case data[(p)] > 13: + if 45 <= data[(p)] && data[(p)] <= 46 { + goto tr42 + } + case data[(p)] >= 9: + goto st25 + } + case data[(p)] > 57: + switch { + case data[(p)] > 90: + if 97 <= data[(p)] && data[(p)] <= 122 { + goto tr43 + } + case data[(p)] >= 65: + goto tr43 + } + default: + goto tr43 + } + goto st2 + tr57: +//line parser.rl:70 + if p-1 > 0 { + for _, b := range noDuplicates { + if data[p] == b && data[p-1] == b { + p = tok - 1 + { + goto st1 + } + } } - case data[(p)] >= 9: - goto tr49 } - goto st1 + + goto st34 + tr58: +//line parser.rl:70 + if p-1 > 0 { + for _, b := range noDuplicates { + if data[p] == b && data[p-1] == b { + p = tok - 1 + { + goto st1 + } + } + } + } + +//line parser.rl:81 + event.SetHostname(data[tok:p]) + + goto st34 st34: if (p)++; (p) == (pe) { goto _test_eof34 } st_case_34: - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st35 +//line parser.go:1033 + switch data[(p)] { + case 32: + goto tr45 + case 58: + goto tr58 + case 95: + goto tr42 + } + switch { + case data[(p)] < 48: + switch { + case data[(p)] > 13: + if 45 <= data[(p)] && data[(p)] <= 46 { + goto tr42 + } + case data[(p)] >= 9: + goto tr45 + } + case data[(p)] > 57: + switch { + case data[(p)] > 90: + if 97 <= data[(p)] && data[(p)] <= 122 { + goto tr43 + } + case data[(p)] >= 65: + goto tr43 + } + default: + goto tr43 + } + goto st2 + tr41: +//line parser.rl:22 + tok = p + +//line parser.rl:70 + if p-1 > 0 { + for _, b := range noDuplicates { + if data[p] == b && data[p-1] == b { + p = tok - 1 + { + goto st1 + } + } + } } - goto st1 + + goto st35 + tr44: +//line parser.rl:70 + if p-1 > 0 { + for _, b := range noDuplicates { + if data[p] == b && data[p-1] == b { + p = tok - 1 + { + goto st1 + } + } + } + } + + goto st35 st35: if (p)++; (p) == (pe) { goto _test_eof35 } st_case_35: - if data[(p)] == 32 { - goto tr49 +//line parser.go:1100 + switch data[(p)] { + case 58: + goto tr57 + case 95: + goto tr42 } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr49 + switch { + case data[(p)] < 48: + if 45 <= data[(p)] && data[(p)] <= 46 { + goto tr42 + } + case data[(p)] > 57: + switch { + case data[(p)] > 90: + if 97 <= data[(p)] && data[(p)] <= 122 { + goto tr43 + } + case data[(p)] >= 65: + goto tr43 + } + default: + goto tr43 } - goto st1 + goto st2 + tr35: +//line parser.rl:58 + event.SetSecond(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st36 + tr69: +//line parser.rl:62 + event.SetNanosecond(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st36 st36: if (p)++; (p) == (pe) { goto _test_eof36 } st_case_36: +//line parser.go:1150 if 48 <= data[(p)] && data[(p)] <= 57 { - goto st34 + goto st37 } - goto st1 - tr33: -//line parser.rl:56 - event.SetSecond(data[tok:p]) - - goto st37 + goto st2 st37: if (p)++; (p) == (pe) { goto _test_eof37 } st_case_37: -//line parser.go:872 if 48 <= data[(p)] && data[(p)] <= 57 { - goto tr53 + goto st38 } - goto st1 - tr53: -//line parser.rl:20 - tok = p - - goto st38 + goto st2 st38: if (p)++; (p) == (pe) { goto _test_eof38 } st_case_38: -//line parser.go:888 switch data[(p)] { case 32: - goto tr54 - case 43: - goto tr55 - case 45: - goto tr55 - case 90: - goto tr57 - case 122: - goto tr57 + goto tr61 + case 58: + goto tr63 } switch { case data[(p)] > 13: if 48 <= data[(p)] && data[(p)] <= 57 { - goto st38 + goto st39 } case data[(p)] >= 9: - goto tr54 + goto tr61 } - goto st1 - tr34: -//line parser.rl:56 - event.SetSecond(data[tok:p]) - -//line parser.rl:20 - tok = p - - goto st39 - tr57: -//line parser.rl:60 - event.SetNanosecond(data[tok:p]) - -//line parser.rl:20 - tok = p - - goto st39 + goto st2 st39: if (p)++; (p) == (pe) { goto _test_eof39 } st_case_39: -//line parser.go:935 - switch data[(p)] { - case 32: - goto tr49 - case 43: - goto st31 - case 45: - goto st31 - } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr49 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st40 } - goto st1 - tr23: -//line parser.rl:20 - tok = p - - goto st40 + goto st2 st40: if (p)++; (p) == (pe) { goto _test_eof40 } st_case_40: -//line parser.go:959 - if 48 <= data[(p)] && data[(p)] <= 51 { - goto st14 + switch data[(p)] { + case 32: + goto tr61 + case 58: + goto tr65 } - goto st1 - tr2: -//line parser.rl:20 - tok = p + if 9 <= data[(p)] && data[(p)] <= 13 { + goto tr61 + } + goto st2 + tr37: +//line parser.rl:58 + event.SetSecond(data[tok:p]) + + goto st41 + tr65: +//line parser.rl:93 + event.SetTimeZone(data[tok:p]) + + goto st41 + tr71: +//line parser.rl:62 + event.SetNanosecond(data[tok:p]) goto st41 st41: @@ -951,14 +1214,17 @@ func Parse(data []byte, event *event) { goto _test_eof41 } st_case_41: -//line parser.go:975 - if 48 <= data[(p)] && data[(p)] <= 57 { - goto tr59 +//line parser.go:1231 + if data[(p)] == 32 { + goto st22 } - goto st1 - tr59: -//line parser.rl:20 - tok = p + if 9 <= data[(p)] && data[(p)] <= 13 { + goto st22 + } + goto st2 + tr63: +//line parser.rl:93 + event.SetTimeZone(data[tok:p]) goto st42 st42: @@ -966,194 +1232,232 @@ func Parse(data []byte, event *event) { goto _test_eof42 } st_case_42: -//line parser.go:991 - if data[(p)] == 62 { - goto tr61 +//line parser.go:1250 + if data[(p)] == 32 { + goto st22 } - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st43 + switch { + case data[(p)] > 13: + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st39 + } + case data[(p)] >= 9: + goto st22 } - goto st1 + goto st2 + tr36: +//line parser.rl:58 + event.SetSecond(data[tok:p]) + + goto st43 st43: if (p)++; (p) == (pe) { goto _test_eof43 } st_case_43: - if data[(p)] == 62 { - goto tr61 - } +//line parser.go:1274 if 48 <= data[(p)] && data[(p)] <= 57 { - goto st44 + goto tr67 } - goto st1 + goto st2 + tr67: +//line parser.rl:22 + tok = p + + goto st44 st44: if (p)++; (p) == (pe) { goto _test_eof44 } st_case_44: - if data[(p)] == 62 { - goto tr61 - } - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st45 - } - goto st1 - st45: - if (p)++; (p) == (pe) { - goto _test_eof45 - } - st_case_45: - if data[(p)] == 62 { - goto tr61 +//line parser.go:1290 + switch data[(p)] { + case 32: + goto tr68 + case 43: + goto tr69 + case 45: + goto tr69 + case 58: + goto tr71 + case 90: + goto tr72 + case 122: + goto tr72 } - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st46 + switch { + case data[(p)] > 13: + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st44 + } + case data[(p)] >= 9: + goto tr68 + } + goto st2 + tr38: +//line parser.rl:58 + event.SetSecond(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st45 + tr72: +//line parser.rl:62 + event.SetNanosecond(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st45 + st45: + if (p)++; (p) == (pe) { + goto _test_eof45 + } + st_case_45: +//line parser.go:1339 + switch data[(p)] { + case 32: + goto tr61 + case 43: + goto st36 + case 45: + goto st36 + case 58: + goto tr65 + } + if 9 <= data[(p)] && data[(p)] <= 13 { + goto tr61 } - goto st1 + goto st2 + tr26: +//line parser.rl:22 + tok = p + + goto st46 st46: if (p)++; (p) == (pe) { goto _test_eof46 } st_case_46: - if data[(p)] == 62 { - goto tr61 +//line parser.go:1365 + if 48 <= data[(p)] && data[(p)] <= 51 { + goto st15 } - goto st1 - tr61: -//line parser.rl:24 - event.SetPriority(data[tok:p]) - - goto st47 + goto st2 st47: if (p)++; (p) == (pe) { goto _test_eof47 } st_case_47: -//line parser.go:1055 - switch data[(p)] { - case 65: - goto tr3 - case 68: - goto tr4 - case 70: - goto tr5 - case 74: - goto tr6 - case 77: - goto tr7 - case 78: - goto tr8 - case 79: - goto tr9 - case 83: - goto tr10 + if data[(p)] == 58 { + goto st48 } if 48 <= data[(p)] && data[(p)] <= 57 { - goto tr1 + goto st47 } - goto tr0 - tr3: -//line parser.rl:20 - tok = p - - goto st48 + goto st2 st48: if (p)++; (p) == (pe) { goto _test_eof48 } st_case_48: -//line parser.go:1089 - switch data[(p)] { - case 112: - goto st49 - case 117: - goto st70 + if data[(p)] == 32 { + goto tr74 + } + if 9 <= data[(p)] && data[(p)] <= 13 { + goto tr74 } - goto st1 + goto st2 + tr74: +//line parser.rl:22 + tok = p + + goto st49 st49: if (p)++; (p) == (pe) { goto _test_eof49 } st_case_49: - if data[(p)] == 114 { - goto st50 +//line parser.go:1405 + switch data[(p)] { + case 65: + goto tr77 + case 68: + goto tr78 + case 70: + goto tr79 + case 74: + goto tr80 + case 77: + goto tr81 + case 78: + goto tr82 + case 79: + goto tr83 + case 83: + goto tr84 } - goto st1 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto tr76 + } + goto tr75 + tr76: +//line parser.rl:97 + event.SetSequence(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st50 st50: if (p)++; (p) == (pe) { goto _test_eof50 } st_case_50: - switch data[(p)] { - case 32: - goto tr68 - case 105: - goto st68 - } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 +//line parser.go:1443 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st51 } - goto st1 - tr68: -//line parser.rl:32 - event.SetMonth(data[tok:p]) - - goto st51 + goto st2 st51: if (p)++; (p) == (pe) { goto _test_eof51 } st_case_51: -//line parser.go:1132 - switch data[(p)] { - case 32: + if 48 <= data[(p)] && data[(p)] <= 57 { goto st52 - case 51: - goto tr72 } - switch { - case data[(p)] < 49: - if 9 <= data[(p)] && data[(p)] <= 13 { - goto st52 - } - case data[(p)] > 50: - if 52 <= data[(p)] && data[(p)] <= 57 { - goto tr73 - } - default: - goto tr71 - } - goto st1 + goto st2 st52: if (p)++; (p) == (pe) { goto _test_eof52 } st_case_52: - if 49 <= data[(p)] && data[(p)] <= 57 { - goto tr73 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st53 } - goto st1 - tr73: -//line parser.rl:20 - tok = p - - goto st53 + goto st2 st53: if (p)++; (p) == (pe) { goto _test_eof53 } st_case_53: -//line parser.go:1172 - if data[(p)] == 32 { - goto tr74 - } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr74 + if data[(p)] == 45 { + goto tr17 } - goto st1 - tr74: -//line parser.rl:44 - event.SetDay(data[tok:p]) + goto st2 + tr3: +//line parser.rl:22 + tok = p + + goto st54 + tr77: +//line parser.rl:97 + event.SetSequence(data[tok:p]) + +//line parser.rl:22 + tok = p goto st54 st54: @@ -1161,41 +1465,41 @@ func Parse(data []byte, event *event) { goto _test_eof54 } st_case_54: -//line parser.go:1191 - if data[(p)] == 50 { - goto tr76 - } - if 48 <= data[(p)] && data[(p)] <= 49 { - goto tr75 +//line parser.go:1496 + switch data[(p)] { + case 112: + goto st55 + case 117: + goto st76 } - goto st1 - tr75: -//line parser.rl:20 - tok = p - - goto st55 + goto st2 st55: if (p)++; (p) == (pe) { goto _test_eof55 } st_case_55: -//line parser.go:1210 - if 48 <= data[(p)] && data[(p)] <= 57 { + if data[(p)] == 114 { goto st56 } - goto st1 + goto st2 st56: if (p)++; (p) == (pe) { goto _test_eof56 } st_case_56: - if data[(p)] == 58 { - goto tr78 + switch data[(p)] { + case 32: + goto tr91 + case 105: + goto st74 } - goto st1 - tr78: -//line parser.rl:48 - event.SetHour(data[tok:p]) + if 9 <= data[(p)] && data[(p)] <= 13 { + goto tr91 + } + goto st2 + tr91: +//line parser.rl:34 + event.SetMonth(data[tok:p]) goto st57 st57: @@ -1203,38 +1507,56 @@ func Parse(data []byte, event *event) { goto _test_eof57 } st_case_57: -//line parser.go:1235 - if 48 <= data[(p)] && data[(p)] <= 53 { - goto tr79 +//line parser.go:1539 + switch data[(p)] { + case 32: + goto st58 + case 51: + goto tr95 } - goto st1 - tr79: -//line parser.rl:20 - tok = p - - goto st58 + switch { + case data[(p)] < 49: + if 9 <= data[(p)] && data[(p)] <= 13 { + goto st58 + } + case data[(p)] > 50: + if 52 <= data[(p)] && data[(p)] <= 57 { + goto tr96 + } + default: + goto tr94 + } + goto st2 st58: if (p)++; (p) == (pe) { goto _test_eof58 } st_case_58: -//line parser.go:1251 - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st59 + if 49 <= data[(p)] && data[(p)] <= 57 { + goto tr96 } - goto st1 + goto st2 + tr96: +//line parser.rl:22 + tok = p + + goto st59 st59: if (p)++; (p) == (pe) { goto _test_eof59 } st_case_59: - if data[(p)] == 58 { - goto tr81 +//line parser.go:1579 + if data[(p)] == 32 { + goto tr97 } - goto st1 - tr81: -//line parser.rl:52 - event.SetMinute(data[tok:p]) + if 9 <= data[(p)] && data[(p)] <= 13 { + goto tr97 + } + goto st2 + tr97: +//line parser.rl:46 + event.SetDay(data[tok:p]) goto st60 st60: @@ -1242,13 +1564,16 @@ func Parse(data []byte, event *event) { goto _test_eof60 } st_case_60: -//line parser.go:1276 - if 48 <= data[(p)] && data[(p)] <= 53 { - goto tr82 +//line parser.go:1598 + if data[(p)] == 50 { + goto tr99 } - goto st1 - tr82: -//line parser.rl:20 + if 48 <= data[(p)] && data[(p)] <= 49 { + goto tr98 + } + goto st2 + tr98: +//line parser.rl:22 tok = p goto st61 @@ -1257,29 +1582,23 @@ func Parse(data []byte, event *event) { goto _test_eof61 } st_case_61: -//line parser.go:1292 +//line parser.go:1617 if 48 <= data[(p)] && data[(p)] <= 57 { goto st62 } - goto st1 + goto st2 st62: if (p)++; (p) == (pe) { goto _test_eof62 } st_case_62: - switch data[(p)] { - case 32: - goto tr31 - case 46: - goto tr84 - } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr31 + if data[(p)] == 58 { + goto tr101 } - goto st1 - tr84: -//line parser.rl:56 - event.SetSecond(data[tok:p]) + goto st2 + tr101: +//line parser.rl:50 + event.SetHour(data[tok:p]) goto st63 st63: @@ -1287,13 +1606,13 @@ func Parse(data []byte, event *event) { goto _test_eof63 } st_case_63: -//line parser.go:1323 - if 48 <= data[(p)] && data[(p)] <= 57 { - goto tr85 +//line parser.go:1642 + if 48 <= data[(p)] && data[(p)] <= 53 { + goto tr102 } - goto st1 - tr85: -//line parser.rl:20 + goto st2 + tr102: +//line parser.rl:22 tok = p goto st64 @@ -1302,59 +1621,37 @@ func Parse(data []byte, event *event) { goto _test_eof64 } st_case_64: -//line parser.go:1339 - if data[(p)] == 32 { - goto tr54 - } - switch { - case data[(p)] > 13: - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st64 - } - case data[(p)] >= 9: - goto tr54 +//line parser.go:1658 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st65 } - goto st1 - tr76: -//line parser.rl:20 - tok = p - - goto st65 + goto st2 st65: if (p)++; (p) == (pe) { goto _test_eof65 } st_case_65: -//line parser.go:1363 - if 48 <= data[(p)] && data[(p)] <= 51 { - goto st56 + if data[(p)] == 58 { + goto tr104 } - goto st1 - tr71: -//line parser.rl:20 - tok = p + goto st2 + tr104: +//line parser.rl:54 + event.SetMinute(data[tok:p]) - goto st66 - st66: - if (p)++; (p) == (pe) { - goto _test_eof66 - } - st_case_66: -//line parser.go:1379 - if data[(p)] == 32 { - goto tr74 - } - switch { - case data[(p)] > 13: - if 48 <= data[(p)] && data[(p)] <= 57 { - goto st53 - } - case data[(p)] >= 9: - goto tr74 + goto st66 + st66: + if (p)++; (p) == (pe) { + goto _test_eof66 } - goto st1 - tr72: -//line parser.rl:20 + st_case_66: +//line parser.go:1683 + if 48 <= data[(p)] && data[(p)] <= 53 { + goto tr105 + } + goto st2 + tr105: +//line parser.rl:22 tok = p goto st67 @@ -1363,487 +1660,780 @@ func Parse(data []byte, event *event) { goto _test_eof67 } st_case_67: -//line parser.go:1403 - if data[(p)] == 32 { - goto tr74 - } - switch { - case data[(p)] > 13: - if 48 <= data[(p)] && data[(p)] <= 49 { - goto st53 - } - case data[(p)] >= 9: - goto tr74 +//line parser.go:1699 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st68 } - goto st1 + goto st2 st68: if (p)++; (p) == (pe) { goto _test_eof68 } st_case_68: - if data[(p)] == 108 { - goto st69 + switch data[(p)] { + case 32: + goto tr34 + case 46: + goto tr107 + case 58: + goto tr37 + } + if 9 <= data[(p)] && data[(p)] <= 13 { + goto tr34 } - goto st1 + goto st2 + tr107: +//line parser.rl:58 + event.SetSecond(data[tok:p]) + + goto st69 st69: if (p)++; (p) == (pe) { goto _test_eof69 } st_case_69: - if data[(p)] == 32 { - goto tr68 - } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 +//line parser.go:1732 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto tr108 } - goto st1 + goto st2 + tr108: +//line parser.rl:22 + tok = p + + goto st70 st70: if (p)++; (p) == (pe) { goto _test_eof70 } st_case_70: - if data[(p)] == 103 { - goto st71 +//line parser.go:1748 + switch data[(p)] { + case 32: + goto tr68 + case 58: + goto tr71 } - goto st1 + switch { + case data[(p)] > 13: + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st70 + } + case data[(p)] >= 9: + goto tr68 + } + goto st2 + tr99: +//line parser.rl:22 + tok = p + + goto st71 st71: if (p)++; (p) == (pe) { goto _test_eof71 } st_case_71: - switch data[(p)] { - case 32: - goto tr68 - case 117: - goto st72 - } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 +//line parser.go:1775 + if 48 <= data[(p)] && data[(p)] <= 51 { + goto st62 } - goto st1 + goto st2 + tr94: +//line parser.rl:22 + tok = p + + goto st72 st72: if (p)++; (p) == (pe) { goto _test_eof72 } st_case_72: - if data[(p)] == 115 { - goto st73 +//line parser.go:1791 + if data[(p)] == 32 { + goto tr97 } - goto st1 + switch { + case data[(p)] > 13: + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st59 + } + case data[(p)] >= 9: + goto tr97 + } + goto st2 + tr95: +//line parser.rl:22 + tok = p + + goto st73 st73: if (p)++; (p) == (pe) { goto _test_eof73 } st_case_73: - if data[(p)] == 116 { - goto st69 +//line parser.go:1815 + if data[(p)] == 32 { + goto tr97 } - goto st1 - tr4: -//line parser.rl:20 - tok = p - - goto st74 + switch { + case data[(p)] > 13: + if 48 <= data[(p)] && data[(p)] <= 49 { + goto st59 + } + case data[(p)] >= 9: + goto tr97 + } + goto st2 st74: if (p)++; (p) == (pe) { goto _test_eof74 } st_case_74: -//line parser.go:1490 - if data[(p)] == 101 { + if data[(p)] == 108 { goto st75 } - goto st1 + goto st2 st75: if (p)++; (p) == (pe) { goto _test_eof75 } st_case_75: - if data[(p)] == 99 { - goto st76 + if data[(p)] == 32 { + goto tr91 + } + if 9 <= data[(p)] && data[(p)] <= 13 { + goto tr91 } - goto st1 + goto st2 st76: if (p)++; (p) == (pe) { goto _test_eof76 } st_case_76: - switch data[(p)] { - case 32: - goto tr68 - case 101: + if data[(p)] == 103 { goto st77 } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 - } - goto st1 + goto st2 st77: if (p)++; (p) == (pe) { goto _test_eof77 } st_case_77: - if data[(p)] == 109 { + switch data[(p)] { + case 32: + goto tr91 + case 117: goto st78 } - goto st1 + if 9 <= data[(p)] && data[(p)] <= 13 { + goto tr91 + } + goto st2 st78: if (p)++; (p) == (pe) { goto _test_eof78 } st_case_78: - if data[(p)] == 98 { + if data[(p)] == 115 { goto st79 } - goto st1 + goto st2 st79: if (p)++; (p) == (pe) { goto _test_eof79 } st_case_79: - if data[(p)] == 101 { - goto st80 + if data[(p)] == 116 { + goto st75 } - goto st1 + goto st2 + tr4: +//line parser.rl:22 + tok = p + + goto st80 + tr78: +//line parser.rl:97 + event.SetSequence(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st80 st80: if (p)++; (p) == (pe) { goto _test_eof80 } st_case_80: - if data[(p)] == 114 { - goto st69 +//line parser.go:1912 + if data[(p)] == 101 { + goto st81 } - goto st1 - tr5: -//line parser.rl:20 - tok = p - - goto st81 + goto st2 st81: if (p)++; (p) == (pe) { goto _test_eof81 } st_case_81: -//line parser.go:1566 - if data[(p)] == 101 { + if data[(p)] == 99 { goto st82 } - goto st1 + goto st2 st82: if (p)++; (p) == (pe) { goto _test_eof82 } st_case_82: - if data[(p)] == 98 { + switch data[(p)] { + case 32: + goto tr91 + case 101: goto st83 } - goto st1 + if 9 <= data[(p)] && data[(p)] <= 13 { + goto tr91 + } + goto st2 st83: if (p)++; (p) == (pe) { goto _test_eof83 } st_case_83: - switch data[(p)] { - case 32: - goto tr68 - case 114: + if data[(p)] == 109 { goto st84 } - if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 - } - goto st1 + goto st2 st84: if (p)++; (p) == (pe) { goto _test_eof84 } st_case_84: - if data[(p)] == 117 { + if data[(p)] == 98 { goto st85 } - goto st1 + goto st2 st85: if (p)++; (p) == (pe) { goto _test_eof85 } st_case_85: - if data[(p)] == 97 { + if data[(p)] == 101 { goto st86 } - goto st1 + goto st2 st86: if (p)++; (p) == (pe) { goto _test_eof86 } st_case_86: if data[(p)] == 114 { - goto st87 + goto st75 } - goto st1 + goto st2 + tr5: +//line parser.rl:22 + tok = p + + goto st87 + tr79: +//line parser.rl:97 + event.SetSequence(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st87 st87: if (p)++; (p) == (pe) { goto _test_eof87 } st_case_87: - if data[(p)] == 121 { - goto st69 +//line parser.go:1998 + if data[(p)] == 101 { + goto st88 } - goto st1 - tr6: -//line parser.rl:20 - tok = p - - goto st88 + goto st2 st88: if (p)++; (p) == (pe) { goto _test_eof88 } st_case_88: -//line parser.go:1642 - switch data[(p)] { - case 97: + if data[(p)] == 98 { goto st89 - case 117: - goto st91 } - goto st1 + goto st2 st89: if (p)++; (p) == (pe) { goto _test_eof89 } st_case_89: - if data[(p)] == 110 { + switch data[(p)] { + case 32: + goto tr91 + case 114: goto st90 } - goto st1 + if 9 <= data[(p)] && data[(p)] <= 13 { + goto tr91 + } + goto st2 st90: if (p)++; (p) == (pe) { - goto _test_eof90 + goto _test_eof90 + } + st_case_90: + if data[(p)] == 117 { + goto st91 + } + goto st2 + st91: + if (p)++; (p) == (pe) { + goto _test_eof91 + } + st_case_91: + if data[(p)] == 97 { + goto st92 + } + goto st2 + st92: + if (p)++; (p) == (pe) { + goto _test_eof92 + } + st_case_92: + if data[(p)] == 114 { + goto st93 + } + goto st2 + st93: + if (p)++; (p) == (pe) { + goto _test_eof93 + } + st_case_93: + if data[(p)] == 121 { + goto st75 + } + goto st2 + tr6: +//line parser.rl:22 + tok = p + + goto st94 + tr80: +//line parser.rl:97 + event.SetSequence(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st94 + st94: + if (p)++; (p) == (pe) { + goto _test_eof94 + } + st_case_94: +//line parser.go:2084 + switch data[(p)] { + case 97: + goto st95 + case 117: + goto st97 + } + goto st2 + st95: + if (p)++; (p) == (pe) { + goto _test_eof95 + } + st_case_95: + if data[(p)] == 110 { + goto st96 + } + goto st2 + st96: + if (p)++; (p) == (pe) { + goto _test_eof96 } - st_case_90: + st_case_96: switch data[(p)] { case 32: - goto tr68 + goto tr91 case 117: - goto st85 + goto st91 } if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 + goto tr91 } - goto st1 - st91: + goto st2 + st97: if (p)++; (p) == (pe) { - goto _test_eof91 + goto _test_eof97 } - st_case_91: + st_case_97: switch data[(p)] { case 108: - goto st92 + goto st98 case 110: - goto st93 + goto st99 } - goto st1 - st92: + goto st2 + st98: if (p)++; (p) == (pe) { - goto _test_eof92 + goto _test_eof98 } - st_case_92: + st_case_98: switch data[(p)] { case 32: - goto tr68 + goto tr91 case 121: - goto st69 + goto st75 } if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 + goto tr91 } - goto st1 - st93: + goto st2 + st99: if (p)++; (p) == (pe) { - goto _test_eof93 + goto _test_eof99 } - st_case_93: + st_case_99: switch data[(p)] { case 32: - goto tr68 + goto tr91 case 101: - goto st69 + goto st75 } if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 + goto tr91 } - goto st1 + goto st2 tr7: -//line parser.rl:20 +//line parser.rl:22 tok = p - goto st94 - st94: + goto st100 + tr81: +//line parser.rl:97 + event.SetSequence(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st100 + st100: if (p)++; (p) == (pe) { - goto _test_eof94 + goto _test_eof100 } - st_case_94: -//line parser.go:1727 + st_case_100: +//line parser.go:2179 if data[(p)] == 97 { - goto st95 + goto st101 } - goto st1 - st95: + goto st2 + st101: if (p)++; (p) == (pe) { - goto _test_eof95 + goto _test_eof101 } - st_case_95: + st_case_101: switch data[(p)] { case 32: - goto tr68 + goto tr91 case 114: - goto st96 + goto st102 case 121: - goto st69 + goto st75 } if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 + goto tr91 } - goto st1 - st96: + goto st2 + st102: if (p)++; (p) == (pe) { - goto _test_eof96 + goto _test_eof102 } - st_case_96: + st_case_102: switch data[(p)] { case 32: - goto tr68 + goto tr91 case 99: - goto st97 + goto st103 } if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 + goto tr91 } - goto st1 - st97: + goto st2 + st103: if (p)++; (p) == (pe) { - goto _test_eof97 + goto _test_eof103 } - st_case_97: + st_case_103: if data[(p)] == 104 { - goto st69 + goto st75 } - goto st1 + goto st2 tr8: -//line parser.rl:20 +//line parser.rl:22 tok = p - goto st98 - st98: + goto st104 + tr82: +//line parser.rl:97 + event.SetSequence(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st104 + st104: if (p)++; (p) == (pe) { - goto _test_eof98 + goto _test_eof104 } - st_case_98: -//line parser.go:1784 + st_case_104: +//line parser.go:2246 if data[(p)] == 111 { - goto st99 + goto st105 } - goto st1 - st99: + goto st2 + st105: if (p)++; (p) == (pe) { - goto _test_eof99 + goto _test_eof105 } - st_case_99: + st_case_105: if data[(p)] == 118 { - goto st76 + goto st82 } - goto st1 + goto st2 tr9: -//line parser.rl:20 +//line parser.rl:22 tok = p - goto st100 - st100: + goto st106 + tr83: +//line parser.rl:97 + event.SetSequence(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st106 + st106: if (p)++; (p) == (pe) { - goto _test_eof100 + goto _test_eof106 } - st_case_100: -//line parser.go:1809 + st_case_106: +//line parser.go:2281 if data[(p)] == 99 { - goto st101 + goto st107 } - goto st1 - st101: + goto st2 + st107: if (p)++; (p) == (pe) { - goto _test_eof101 + goto _test_eof107 } - st_case_101: + st_case_107: if data[(p)] == 116 { - goto st102 + goto st108 } - goto st1 - st102: + goto st2 + st108: if (p)++; (p) == (pe) { - goto _test_eof102 + goto _test_eof108 } - st_case_102: + st_case_108: switch data[(p)] { case 32: - goto tr68 + goto tr91 case 111: - goto st78 + goto st84 } if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 + goto tr91 } - goto st1 + goto st2 tr10: -//line parser.rl:20 +//line parser.rl:22 tok = p - goto st103 - st103: + goto st109 + tr84: +//line parser.rl:97 + event.SetSequence(data[tok:p]) + +//line parser.rl:22 + tok = p + + goto st109 + st109: if (p)++; (p) == (pe) { - goto _test_eof103 + goto _test_eof109 } - st_case_103: -//line parser.go:1849 + st_case_109: +//line parser.go:2331 if data[(p)] == 101 { - goto st104 + goto st110 } - goto st1 - st104: + goto st2 + st110: if (p)++; (p) == (pe) { - goto _test_eof104 + goto _test_eof110 } - st_case_104: + st_case_110: if data[(p)] == 112 { - goto st105 + goto st111 } - goto st1 - st105: + goto st2 + st111: if (p)++; (p) == (pe) { - goto _test_eof105 + goto _test_eof111 } - st_case_105: + st_case_111: switch data[(p)] { case 32: - goto tr68 + goto tr91 case 116: - goto st106 + goto st112 } if 9 <= data[(p)] && data[(p)] <= 13 { - goto tr68 + goto tr91 } - goto st1 - st106: + goto st2 + st112: if (p)++; (p) == (pe) { - goto _test_eof106 + goto _test_eof112 } - st_case_106: + st_case_112: if data[(p)] == 101 { - goto st77 + goto st83 + } + goto st2 + tr2: +//line parser.rl:22 + tok = p + + goto st113 + st113: + if (p)++; (p) == (pe) { + goto _test_eof113 + } + st_case_113: +//line parser.go:2380 + if 48 <= data[(p)] && data[(p)] <= 57 { + goto tr141 + } + goto st2 + tr141: +//line parser.rl:22 + tok = p + + goto st114 + st114: + if (p)++; (p) == (pe) { + goto _test_eof114 + } + st_case_114: +//line parser.go:2396 + if data[(p)] == 62 { + goto tr143 + } + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st115 + } + goto st2 + st115: + if (p)++; (p) == (pe) { + goto _test_eof115 + } + st_case_115: + if data[(p)] == 62 { + goto tr143 + } + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st116 + } + goto st2 + st116: + if (p)++; (p) == (pe) { + goto _test_eof116 + } + st_case_116: + if data[(p)] == 62 { + goto tr143 + } + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st117 + } + goto st2 + st117: + if (p)++; (p) == (pe) { + goto _test_eof117 + } + st_case_117: + if data[(p)] == 62 { + goto tr143 + } + if 48 <= data[(p)] && data[(p)] <= 57 { + goto st118 + } + goto st2 + st118: + if (p)++; (p) == (pe) { + goto _test_eof118 + } + st_case_118: + if data[(p)] == 62 { + goto tr143 + } + goto st2 + tr143: +//line parser.rl:26 + event.SetPriority(data[tok:p]) + + goto st119 + st119: + if (p)++; (p) == (pe) { + goto _test_eof119 + } + st_case_119: +//line parser.go:2460 + switch data[(p)] { + case 65: + goto tr3 + case 68: + goto tr4 + case 70: + goto tr5 + case 74: + goto tr6 + case 77: + goto tr7 + case 78: + goto tr8 + case 79: + goto tr9 + case 83: + goto tr10 + } + if 48 <= data[(p)] && data[(p)] <= 57 { + goto tr1 + } + goto tr0 + st1: + if (p)++; (p) == (pe) { + goto _test_eof1 + } + st_case_1: + goto tr11 + tr11: +//line parser.rl:22 + tok = p + + goto st120 + st120: + if (p)++; (p) == (pe) { + goto _test_eof120 } - goto st1 + st_case_120: +//line parser.go:2500 + goto st120 st_out: - _test_eof1: - cs = 1 - goto _test_eof _test_eof2: cs = 2 goto _test_eof @@ -2159,21 +2749,66 @@ func Parse(data []byte, event *event) { _test_eof106: cs = 106 goto _test_eof + _test_eof107: + cs = 107 + goto _test_eof + _test_eof108: + cs = 108 + goto _test_eof + _test_eof109: + cs = 109 + goto _test_eof + _test_eof110: + cs = 110 + goto _test_eof + _test_eof111: + cs = 111 + goto _test_eof + _test_eof112: + cs = 112 + goto _test_eof + _test_eof113: + cs = 113 + goto _test_eof + _test_eof114: + cs = 114 + goto _test_eof + _test_eof115: + cs = 115 + goto _test_eof + _test_eof116: + cs = 116 + goto _test_eof + _test_eof117: + cs = 117 + goto _test_eof + _test_eof118: + cs = 118 + goto _test_eof + _test_eof119: + cs = 119 + goto _test_eof + _test_eof1: + cs = 1 + goto _test_eof + _test_eof120: + cs = 120 + goto _test_eof _test_eof: { } if (p) == eof { switch cs { - case 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, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106: -//line parser.rl:28 + case 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, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120: +//line parser.rl:30 event.SetMessage(data[tok:p]) -//line parser.go:2003 +//line parser.go:2632 } } } -//line parser.rl:84 +//line parser.rl:105 } diff --git a/filebeat/input/syslog/parser.rl b/filebeat/input/syslog/parser.rl index cbfd32362aec..e5b2c1b143fe 100644 --- a/filebeat/input/syslog/parser.rl +++ b/filebeat/input/syslog/parser.rl @@ -8,9 +8,11 @@ package syslog variable pe pe; }%% -// syslog -//<34>Oct 11 22:14:15 wopr su: 'su root' failed for foobar -//<13>Feb 5 17:32:18 10.0.0.99 Use the quad dmg. +var ( + noDuplicates = []byte{'-', '.'} +) + +// Parse parses Syslog events. func Parse(data []byte, event *event) { var p, cs int pe := len(data) @@ -61,6 +63,21 @@ func Parse(data []byte, event *event) { event.SetNanosecond(data[tok:p]) } + # NOTES: This allow to bail out of obvious non valid + # hostname, this might not be ideal in all situation, but + # when this happen we just go to the catch all case and at least + # extract the message + action lookahead_duplicates{ + if p-1 > 0 { + for _, b := range noDuplicates { + if data[p] == b && data[p-1] == b { + p = tok -1 + fgoto catch_all; + } + } + } + } + action hostname { event.SetHostname(data[tok:p]) } @@ -77,6 +94,10 @@ func Parse(data []byte, event *event) { event.SetTimeZone(data[tok:p]) } + action sequence { + event.SetSequence(data[tok:p]) + } + include syslog_rfc3164 "syslog_rfc3164.rl"; write init; diff --git a/filebeat/input/syslog/parser_test.go b/filebeat/input/syslog/parser_test.go index 68abc2e3f129..161cc3779dfc 100644 --- a/filebeat/input/syslog/parser_test.go +++ b/filebeat/input/syslog/parser_test.go @@ -31,6 +31,25 @@ func TestParseSyslog(t *testing.T) { log []byte syslog event }{ + { + title: "Cisco's syslog", + log: []byte("<190>589265: Feb 8 18:55:31.306: %SEC-11-IPACCESSLOGP: list 177 denied udp 10.0.0.1(53640) -> 10.100.0.1(15600), 1 packet"), + syslog: event{ + priority: 190, + message: "%SEC-11-IPACCESSLOGP: list 177 denied udp 10.0.0.1(53640) -> 10.100.0.1(15600), 1 packet", + hostname: "", + program: "", + pid: -1, + month: 2, + day: 8, + year: 2018, + hour: 18, + minute: 55, + second: 31, + nanosecond: 306000000, + sequence: 589265, + }, + }, { title: "no timezone in date", log: []byte("<190>2018-06-19 02:13:38 super mon message"), @@ -507,6 +526,96 @@ func TestParseSyslog(t *testing.T) { second: 18, }, }, + { + title: "ipv6: 1::", + log: []byte("<13>Feb 25 17:32:18 1:: Use the Force!"), + syslog: event{ + message: "Use the Force!", + hostname: "1::", + priority: 13, + pid: -1, + month: 2, + day: 25, + hour: 17, + minute: 32, + second: 18, + }, + }, + { + title: "ipv6: 1::2", + log: []byte("<13>Feb 25 17:32:18 1::2 Use the Force!"), + syslog: event{ + message: "Use the Force!", + hostname: "1::2", + priority: 13, + pid: -1, + month: 2, + day: 25, + hour: 17, + minute: 32, + second: 18, + }, + }, + { + title: "ipv6: 1::2:5", + log: []byte("<13>Feb 25 17:32:18 1::2:5 Use the Force!"), + syslog: event{ + message: "Use the Force!", + hostname: "1::2:5", + priority: 13, + pid: -1, + month: 2, + day: 25, + hour: 17, + minute: 32, + second: 18, + }, + }, + { + title: "ipv4 mapped on ipv6", + log: []byte("<13>Feb 25 17:32:18 ::ffff:0:255.255.255.255 Use the Force!"), + syslog: event{ + message: "Use the Force!", + hostname: "::ffff:0:255.255.255.255", + priority: 13, + pid: -1, + month: 2, + day: 25, + hour: 17, + minute: 32, + second: 18, + }, + }, + { + title: "ipv4 embedded on ipv6", + log: []byte("<13>Feb 25 17:32:18 60::ffff::10.0.1.120 Use the Force!"), + syslog: event{ + message: "Use the Force!", + hostname: "60::ffff::10.0.1.120", + priority: 13, + pid: -1, + month: 2, + day: 25, + hour: 17, + minute: 32, + second: 18, + }, + }, + { + title: "ipv6: 1:2:3:4:5:6:7:8", + log: []byte("<13>Feb 25 17:32:18 1:2:3:4:5:6:7:8 Use the Force!"), + syslog: event{ + message: "Use the Force!", + hostname: "1:2:3:4:5:6:7:8", + priority: 13, + pid: -1, + month: 2, + day: 25, + hour: 17, + minute: 32, + second: 18, + }, + }, { title: "Number inf the host", log: []byte("<164>Oct 26 15:19:25 1.2.3.4 ASA1-2: Deny udp src DRAC:10.1.2.3/43434 dst outside:192.168.0.1/53 by access-group \"acl_drac\" [0x0, 0x0]"), diff --git a/filebeat/input/syslog/syslog_rfc3164.rl b/filebeat/input/syslog/syslog_rfc3164.rl index 2a5638f29a03..e16b9da35da4 100644 --- a/filebeat/input/syslog/syslog_rfc3164.rl +++ b/filebeat/input/syslog/syslog_rfc3164.rl @@ -42,10 +42,11 @@ timestamp_rfc3164 = month space day space time; time_separator = "T" | "t"; timestamp_rfc3339 = year "-" month_numeric "-" day_two_digits (time_separator | space) time timezone?; - timestamp = timestamp_rfc3339 | timestamp_rfc3164; + timestamp = (timestamp_rfc3339 | timestamp_rfc3164) ":"?; - hostname = [a-zA-Z0-9.-_:]+>tok %hostname; - header = timestamp space hostname space; + hostname = ([a-zA-Z0-9\.\-_:]*([a-zA-Z0-9] | "::"))+>tok $lookahead_duplicates %hostname; + hostVars = (hostname ":") | hostname; + header = timestamp space hostVars ":"? space; # MSG # https://tools.ietf.org/html/rfc3164#section-4.1.3 @@ -54,7 +55,9 @@ syslogprog = program ("[" pid "]")? ":" space; message = any+>tok %message; msg = syslogprog? message>tok %message; + sequence = digit+ ":" space>tok %sequence; - main := (prio)? (header msg | timestamp space message | message); + main := (prio)?(sequence)? (header msg | timestamp space message | message); + catch_all := message; }%%