Initial importHEADmaster

6 files changed, 1143 insertions, 0 deletions

diff --git a/six/feed_parser.go b/six/feed_parser.go
new file mode 100644
index 0000000..fb839f7
--- /dev/null
+++ b/six/feed_parser.go
@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// Copyright (C) 2020 Michael Crute <mike@crute.us>. All rights reserved.
+//
+// Use of this source code is governed by a license that can be found in the
+// LICENSE file.
+
+package six
+
+import (
+        "encoding/csv"
+        "fmt"
+        "io"
+        "net/http"
+        "os"
+)
+
+const sixFeedUrl = "https://www.seattleix.net/autogen/participants.csv"
+
+// Error indicating that a line in the SIX CSV feed could not be parsed.
+// Contains the actual error as well as the line number on which the error
+// occurred.
+type SIXParticipantParseError struct {
+        Line int
+        Err  error
+}
+
+// Return the error string for the error
+func (e *SIXParticipantParseError) Error() string {
+        return fmt.Sprintf("record on line %d: %s", e.Line, e.Err)
+}
+
+// Returns the wrapped error
+func (e *SIXParticipantParseError) Unwrap() error {
+        return e.Err
+}
+
+// Parser for the SIX participant CSV feed.
+type SIXParser struct {
+        Records  []*SIXParticipant
+        Errors   []error
+        asnIndex map[int][]*SIXParticipant
+        headers  []string
+}
+
+// Builds a new SIXParser
+func NewSIXParser() *SIXParser {
+        return &SIXParser{
+                Records:  []*SIXParticipant{},
+                Errors:   []error{},
+                asnIndex: map[int][]*SIXParticipant{},
+                headers:  nil,
+        }
+}
+
+// After parsing the feed will return a list of participant structs for the
+// passed ASN as well as a boolean indicating if the participant exists.
+// Participants may have several connections to the exchange and each
+// connection is a different participant.
+func (p *SIXParser) GetParticipantByASN(asn int) ([]*SIXParticipant, bool) {
+        r, ok := p.asnIndex[asn]
+        return r, ok
+}
+
+// Adds a participant to the SIXParticipant struct
+func (p *SIXParser) AddParticipant(sp *SIXParticipant) {
+        p.Records = append(p.Records, sp)
+
+        if _, ok := p.asnIndex[sp.ASN]; !ok {
+                p.asnIndex[sp.ASN] = []*SIXParticipant{sp}
+        } else {
+                p.asnIndex[sp.ASN] = append(p.asnIndex[sp.ASN], sp)
+        }
+}
+
+func (p *SIXParser) sliceToHeaderMap(s []string) map[string]string {
+        r := map[string]string{}
+        for i, k := range p.headers {
+                r[k] = s[i]
+        }
+        return r
+}
+
+func (p *SIXParser) addRow(rn int, r []string) {
+        defer func() {
+                if e := recover(); e != nil {
+                        p.Errors = append(p.Errors, &SIXParticipantParseError{
+                                Line: rn,
+                                Err:  e.(error),
+                        })
+                }
+        }()
+        p.AddParticipant(NewSIXParticipantFromData(p.sliceToHeaderMap(r)))
+}
+
+// ASSUMPTION: The correct row size will not change
+//
+// Participants that aren't using the route servers tend to have inconsistent
+// row data. The head and tail of the row are fine and contain the organization
+// and connection information but the middle area that contains route server
+// stats generally has 7-9 too few columns. This function will graft the head
+// and tail onto an appropriately sized row.
+func (p *SIXParser) fixupRow(r []string) []string {
+        k := make([]string, 49)
+        copy(k[:18], r[:18])
+        copy(k[42:], r[len(r)-7:])
+        return k
+}
+
+// Parse an io.Reader containing SIX participant data in CSV format and collect
+// the results into the parser for later querying.
+func (p *SIXParser) Parse(fr io.Reader) {
+        rn := 0
+        cr := csv.NewReader(fr)
+        for {
+                rn++
+                row, err := cr.Read()
+                if err == io.EOF {
+                        return
+                }
+                if err != nil {
+                        row = p.fixupRow(row)
+                        p.Errors = append(p.Errors, err)
+                }
+                if p.headers == nil {
+                        p.headers = row
+                        continue
+                }
+                p.addRow(rn, row)
+        }
+}
+
+// Create a new SIXParser and parse the CSV file pointed to by the filename.
+func ParseSIXCSV(filename string) (*SIXParser, error) {
+        fp, err := os.Open(filename)
+        if err != nil {
+                return nil, err
+        }
+        defer fp.Close()
+
+        sp := NewSIXParser()
+        sp.Parse(fp)
+
+        return sp, nil
+}
+
+// Create a new SIXParser and parse the contents of the SIX participant file
+// locate on the SIX http server.
+func FetchParseSIXCSV() (*SIXParser, error) {
+        res, err := http.Get(sixFeedUrl)
+        if err != nil {
+                return nil, err
+        }
+        defer res.Body.Close()
+
+        sp := NewSIXParser()
+        sp.Parse(res.Body)
+
+        return sp, nil
+}
diff --git a/six/helpers.go b/six/helpers.go
new file mode 100644
index 0000000..694a79e
--- /dev/null
+++ b/six/helpers.go
@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// Copyright (C) 2020 Michael Crute <mike@crute.us>. All rights reserved.
+//
+// Use of this source code is governed by a license that can be found in the
+// LICENSE file.
+
+package six
+
+import (
+        "net"
+        "strconv"
+        "strings"
+        "time"
+)
+
+func mustParseInt(a string) int {
+        a = strings.TrimSpace(a)
+
+        if a == "" {
+                return 0
+        }
+
+        i, err := strconv.Atoi(a)
+        if err != nil {
+                panic(err)
+        }
+
+        return i
+}
+
+func parseYesNo(b string) bool {
+        return strings.ToLower(strings.TrimSpace(b)) == "yes"
+}
+
+func parseIP(i string) *net.IP {
+        o := net.ParseIP(i)
+        return &o
+}
+
+func parseIPNetFromCIDR(i string) *net.IPNet {
+        _, ipnet, _ := net.ParseCIDR(strings.TrimSpace(i))
+        return ipnet
+}
+
+func mustParseTime(t string) *time.Time {
+        t = strings.TrimSpace(t)
+
+        if t == "" {
+                return nil
+        }
+
+        i, err := time.Parse("2006-01-02", t)
+        if err != nil {
+                panic(err)
+        }
+
+        return &i
+}
+
+func mustParseLongTime(t string) *time.Time {
+        t = strings.TrimSpace(t)
+
+        if t == "" {
+                return nil
+        }
+
+        i, err := time.Parse("2006-01-02 15:04:05 MST", t)
+        if err != nil {
+                panic(err)
+        }
+
+        return &i
+}
+
+func mustParseLongTimeNoZone(t string) *time.Time {
+        t = strings.TrimSpace(t)
+
+        if t == "" {
+                return nil
+        }
+
+        i, err := time.Parse("2006-01-02 15:04:05", t)
+        if err != nil {
+                panic(err)
+        }
+
+        return &i
+}
+
+func allEmpty(d []string) bool {
+        for _, v := range d {
+                if strings.TrimSpace(v) != "" {
+                        return false
+                }
+        }
+        return true
+}
+
+func parseASPath(p string) []int {
+        out := []int{}
+
+        for _, i := range strings.Split(p, " ") {
+                ii, err := strconv.Atoi(strings.TrimSpace(i))
+                // Some AS paths contain { and } which are not valid and need to be discard
+                if err != nil {
+                        continue
+                }
+                out = append(out, ii)
+        }
+
+        return out
+}
diff --git a/six/info_file_parser.go b/six/info_file_parser.go
new file mode 100644
index 0000000..cf98280
--- /dev/null
+++ b/six/info_file_parser.go
@@ -0,0 +1,279 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// Copyright (C) 2020 Michael Crute <mike@crute.us>. All rights reserved.
+//
+// Use of this source code is governed by a license that can be found in the
+// LICENSE file.
+
+package six
+
+import (
+        "fmt"
+        "io/ioutil"
+        "net"
+        "net/http"
+        "regexp"
+        "strings"
+)
+
+const (
+        roaUrl      = "https://www.seattleix.net/rs/rpki_roas/%d.txt"                  // ASN
+        pfxUrl      = "https://www.seattleix.net/rs/irr_prefixes/%d.v%d.txt"           // ASN, IP Version
+        asnUrl      = "https://www.seattleix.net/rs/irr_asns/%d.v%d.txt"               // ASN, IP Version
+        asSetUrl    = "https://www.seattleix.net/rs/irr_as-set_prefixes/%d.v%d.txt"    // ASN, IP Version
+        rsPrefixUrl = "https://www.seattleix.net/rs/rs%d.%d.v%d/%d:1:%d:v%d.txt"       // RS#, MTU, IP Version, ASN, MTU, IP Version
+        rsErrUrl    = "https://www.seattleix.net/rs/rs%d.%d.v%d/%d:1:%d:v%d.%serr.txt" // RS#, MTU, IP Version, ASN, MTU, IP Version, x for xerr
+)
+
+// Date, ASN, MTU, IP Version, Net Name, Network, Source, AS Path (may have {}), Error Message
+// See tests for line examples
+var errorLineRegex = regexp.MustCompile(`(?P<datetime>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) <[^>]+> (?P<asn>\d+):1:(?P<mtu>\d+):v(?P<ip_version>[46]):(?P<net_name>[^:]+): (?P<target>(?:[0-9\.\/]+|[0-9a-f\/:]+)) from (?P<source>(?:[0-9\.]+|[0-9a-f:]+?)):? (?:(?:bgp_path)?\(path (?P<path>[\d {}]+)\):?)? ?(?P<error>.*)`)
+
+func fetchParseRSErrors(rsNum, asn int, forTransit bool) *Errors {
+        transit := ""
+        if forTransit {
+                transit = "x"
+        }
+
+        // Not everyone will have every file and parseErrorFiles ignores nil so
+        // just ignore errors here
+        v4, _ := fetchFile(rsErrUrl, rsNum, 1500, IPv4, asn, 1500, IPv4, transit)
+        v6, _ := fetchFile(rsErrUrl, rsNum, 1500, IPv6, asn, 1500, IPv6, transit)
+        v4j, _ := fetchFile(rsErrUrl, rsNum, 9000, IPv4, asn, 9000, IPv4, transit)
+        v6j, _ := fetchFile(rsErrUrl, rsNum, 9000, IPv6, asn, 9000, IPv6, transit)
+
+        return parseErrorFiles(v4, v6, v4j, v6j)
+}
+
+func fetchParseRoutes(rsNum, asn int, ipv IPVersion, forJumbo bool) (*RouteFile, error) {
+        mtu := 1500
+        if forJumbo {
+                mtu = 9000
+        }
+
+        f, err := fetchFile(rsPrefixUrl, rsNum, mtu, ipv, asn, mtu, ipv)
+        if err != nil {
+                return nil, err
+        }
+
+        return parseRoutesFile(f), nil
+}
+
+func fetchParseASSet(asn int, ipv IPVersion) (*ASSet, error) {
+        f, err := fetchFile(asnUrl, asn, ipv)
+        if err != nil {
+                return nil, err
+        }
+        return parseASSetFile(f), nil
+}
+
+func fetchParsePrefixList(asn int, ipv IPVersion, forAsSet bool) (*PrefixSet, error) {
+        url := pfxUrl
+        if forAsSet {
+                url = asSetUrl
+        }
+
+        f, err := fetchFile(url, asn, ipv)
+        if err != nil {
+                return nil, err
+        }
+        return parsePrefixSetFile(f), nil
+}
+
+func fetchParseROAFile(asn int) (*ROASet, error) {
+        f, err := fetchFile(roaUrl, asn)
+        if err != nil {
+                return nil, err
+        }
+        return parseROAFile(f), nil
+}
+
+func fetchFile(urlTpl string, args ...interface{}) ([]string, error) {
+        r, err := http.Get(fmt.Sprintf(urlTpl, args...))
+        if err != nil {
+                return nil, err
+        }
+        defer r.Body.Close()
+
+        b, err := ioutil.ReadAll(r.Body)
+        if err != nil {
+                return nil, err
+        }
+
+        return strings.Split(string(b), "\n"), nil
+}
+
+func parseROAFile(lines []string) *ROASet {
+        rs := &ROASet{
+                ROAS: []ROA{},
+        }
+
+        for _, line := range lines {
+                if strings.HasPrefix(line, "Timestamp:") {
+                        rs.Timestamp = *mustParseLongTime(line[11:])
+                        continue
+                } else if strings.HasPrefix(line, "Trust Anchor") {
+                        continue
+                } else if strings.TrimSpace(line) == "" {
+                        continue
+                } else {
+                        lp := strings.Split(line, "|")
+                        rs.ROAS = append(rs.ROAS, ROA{
+                                TrustAnchor: strings.TrimSpace(lp[0]),
+                                ASN:         mustParseInt(lp[1]),
+                                MaxLength:   mustParseInt(lp[2]),
+                                Prefix:      *parseIPNetFromCIDR(lp[3]),
+                        })
+                }
+        }
+
+        return rs
+}
+
+func parsePrefixSetFile(lines []string) *PrefixSet {
+        ps := &PrefixSet{
+                Prefixes: []net.IPNet{},
+        }
+
+        for _, line := range lines {
+                if strings.HasPrefix(line, "Timestamp:") {
+                        ps.Timestamp = *mustParseLongTime(line[11:])
+                        continue
+                } else if strings.HasPrefix(line, "as-set:") {
+                        ps.ASSet = &strings.Split(line, " ")[1]
+                        continue
+                } else if strings.TrimSpace(line) == "" {
+                        continue
+                } else {
+                        // Data formatting error on SIX side
+                        if strings.HasSuffix(line, ",") {
+                                line = line[:len(line)-1]
+                        }
+                        ps.Prefixes = append(ps.Prefixes, *parseIPNetFromCIDR(line))
+                }
+        }
+
+        return ps
+}
+
+func parseASSetFile(lines []string) *ASSet {
+        as := &ASSet{
+                ASNumbers: []int{},
+        }
+
+        for _, line := range lines {
+                if strings.HasPrefix(line, "Timestamp:") {
+                        as.Timestamp = *mustParseLongTime(line[11:])
+                        continue
+                } else if strings.HasPrefix(line, "as-set:") {
+                        as.Name = strings.Split(line, " ")[1]
+                        continue
+                } else if strings.TrimSpace(line) == "" {
+                        continue
+                } else {
+                        as.ASNumbers = append(as.ASNumbers, mustParseInt(line))
+                }
+        }
+
+        return as
+}
+
+func parseErrorFiles(v4, v6, v4j, v6j []string) *Errors {
+        e := &Errors{}
+
+        if v4 != nil {
+                parseErrorFile(v4, e, IPv4, false)
+        }
+        if v6 != nil {
+                parseErrorFile(v6, e, IPv6, false)
+        }
+        if v4j != nil {
+                parseErrorFile(v4j, e, IPv4, true)
+        }
+        if v6j != nil {
+                parseErrorFile(v6j, e, IPv6, true)
+        }
+
+        return e
+}
+
+func getTarget(e *Errors, ipv IPVersion, jumbo bool) *ErrorRecords {
+        if ipv == IPv4 && jumbo {
+                if e.IPv4Jumbo == nil {
+                        e.IPv4Jumbo = NewErrorRecords()
+                }
+                return e.IPv4Jumbo
+        } else if ipv == IPv6 && jumbo {
+                if e.IPv6Jumbo == nil {
+                        e.IPv6Jumbo = NewErrorRecords()
+                }
+                return e.IPv6Jumbo
+        } else if ipv == IPv4 {
+                if e.IPv4 == nil {
+                        e.IPv4 = NewErrorRecords()
+                }
+                return e.IPv4
+        } else if ipv == IPv6 {
+                if e.IPv6 == nil {
+                        e.IPv6 = NewErrorRecords()
+                }
+                return e.IPv6
+        } else {
+                // This should not be possible
+                panic("Could not find target")
+        }
+}
+
+func parseErrorFile(lines []string, e *Errors, ipv IPVersion, jumbo bool) {
+        t := getTarget(e, ipv, jumbo)
+
+        for _, line := range lines {
+                l := parseErrorLine(line)
+                if l == nil {
+                        // Skip blank lines, which sometimes happen
+                        if strings.TrimSpace(line) == "" {
+                                continue
+                        } else {
+                                t.UnparsableLines = append(t.UnparsableLines, line)
+                        }
+                } else {
+                        t.Records = append(t.Records, *l)
+                }
+        }
+}
+
+func parseErrorLine(line string) *ErrorRecord {
+        res := errorLineRegex.FindAllStringSubmatch(line, -1)
+        if len(res) == 0 {
+                return nil
+        } else {
+                row := res[0][1:]
+                return &ErrorRecord{
+                        Timestamp:   *mustParseLongTimeNoZone(row[0]),
+                        ASN:         mustParseInt(row[1]),
+                        MTU:         mustParseInt(row[2]),
+                        Version:     IPVersion(mustParseInt(row[3])),
+                        NetworkName: row[4],
+                        Network:     *parseIPNetFromCIDR(row[5]),
+                        Router:      *parseIP(row[6]),
+                        Path:        parseASPath(row[7]),
+                        Message:     row[8],
+                }
+        }
+}
+
+func parseRoutesFile(lines []string) *RouteFile {
+        ps := &RouteFile{
+                Lines: []string{},
+        }
+        for _, line := range lines {
+                if strings.HasPrefix(line, "Timestamp:") {
+                        ps.Timestamp = *mustParseLongTime(line[11:])
+                        continue
+                } else if strings.TrimSpace(line) == "" {
+                        continue
+                } else {
+                        ps.Lines = append(ps.Lines, line)
+                }
+        }
+        return ps
+}
diff --git a/six/info_file_parser_test.go b/six/info_file_parser_test.go
new file mode 100644
index 0000000..9994e6f
--- /dev/null
+++ b/six/info_file_parser_test.go
@@ -0,0 +1,256 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// Copyright (C) 2020 Michael Crute <mike@crute.us>. All rights reserved.
+//
+// Use of this source code is governed by a license that can be found in the
+// LICENSE file.
+
+package six
+
+import (
+        "net"
+        "strings"
+        "testing"
+        "time"
+
+        "github.com/stretchr/testify/assert"
+)
+
+var testDate = time.Date(2020, 02, 12, 19, 43, 23, 0, time.UTC)
+
+const roaTest = `
+Timestamp: 2020-02-12 19:43:23 UTC
+Trust Anchor |        ASN | Max Length | Prefix
+       APNIC |      64496 |         24 | 192.0.2.0/24
+        RIPE |      64496 |         24 | 198.51.100.0/24
+                RIPE |      64496 |         48 | 2001:db8:3a80::/48
+           APNIC |      64496 |         48 | 2001:db8:3a81::/48
+`
+
+func parseCidr(c string) net.IPNet {
+        _, n, _ := net.ParseCIDR(c)
+        return *n
+}
+
+func TestROAParsing(t *testing.T) {
+        rs := parseROAFile(strings.Split(roaTest, "\n"))
+
+        matrix := []struct {
+                TrustAnchor string
+                ASN         int
+                MaxLength   int
+                Prefix      net.IPNet
+        }{
+                {"APNIC", 64496, 24, parseCidr("192.0.2.0/24")},
+                {"RIPE", 64496, 24, parseCidr("198.51.100.0/24")},
+                {"RIPE", 64496, 48, parseCidr("2001:db8:3a80::/48")},
+                {"APNIC", 64496, 48, parseCidr("2001:db8:3a81::/48")},
+        }
+
+        for i, tv := range matrix {
+                assert.EqualValues(t, tv, rs.ROAS[i])
+        }
+
+        assert.Equal(t, rs.Timestamp, testDate)
+}
+
+const prefixListv4 = `
+Timestamp: 2020-02-12 19:43:23 UTC
+192.0.2.0/24
+198.51.100.0/24
+`
+
+func TestPrefixSetv4Parsing(t *testing.T) {
+        r := parsePrefixSetFile(strings.Split(prefixListv4, "\n"))
+
+        assert.Equal(t, r.Timestamp, testDate)
+        assert.Equal(t, r.Prefixes[0], parseCidr("192.0.2.0/24"))
+        assert.Equal(t, r.Prefixes[1], parseCidr("198.51.100.0/24"))
+}
+
+const prefixListv6 = `
+Timestamp: 2020-02-12 19:43:23 UTC
+2001:db8:3a80::/48
+2001:db8:3a81::/48
+`
+
+func TestPrefixSetv6Parsing(t *testing.T) {
+        r := parsePrefixSetFile(strings.Split(prefixListv6, "\n"))
+
+        assert.Equal(t, r.Timestamp, testDate)
+        assert.Equal(t, r.Prefixes[0], parseCidr("2001:db8:3a80::/48"))
+        assert.Equal(t, r.Prefixes[1], parseCidr("2001:db8:3a81::/48"))
+}
+
+const asPrefixListv4 = `
+as-set: AS-TEST
+Timestamp: 2020-02-12 19:43:23 UTC
+192.0.2.0/24
+198.51.100.0/24
+198.51.100.0/24,
+`
+
+func TestPrefixSetASNv4Parsing(t *testing.T) {
+        r := parsePrefixSetFile(strings.Split(asPrefixListv4, "\n"))
+
+        assert.Equal(t, r.Timestamp, testDate)
+        assert.Equal(t, *r.ASSet, "AS-TEST")
+        assert.Equal(t, r.Prefixes[0], parseCidr("192.0.2.0/24"))
+        assert.Equal(t, r.Prefixes[1], parseCidr("198.51.100.0/24"))
+        assert.Equal(t, r.Prefixes[2], parseCidr("198.51.100.0/24"))
+}
+
+const asPrefixListv6 = `
+as-set: AS-TEST
+Timestamp: 2020-02-12 19:43:23 UTC
+2001:db8:3a80::/48
+2001:db8:3a81::/48
+2001:db8:3a81::/48,
+`
+
+func TestPrefixSetASNv6Parsing(t *testing.T) {
+        r := parsePrefixSetFile(strings.Split(asPrefixListv6, "\n"))
+
+        assert.Equal(t, r.Timestamp, testDate)
+        assert.Equal(t, *r.ASSet, "AS-TEST")
+        assert.Equal(t, r.Prefixes[0], parseCidr("2001:db8:3a80::/48"))
+        assert.Equal(t, r.Prefixes[1], parseCidr("2001:db8:3a81::/48"))
+        assert.Equal(t, r.Prefixes[2], parseCidr("2001:db8:3a81::/48"))
+}
+
+const asSetFile = `
+as-set: AS-TEST
+Timestamp: 2020-02-12 19:43:23 UTC
+64496
+64497
+64498
+`
+
+func TestASSetParsing(t *testing.T) {
+        r := parseASSetFile(strings.Split(asSetFile, "\n"))
+
+        assert.Equal(t, r.Timestamp, testDate)
+        assert.Equal(t, r.Name, "AS-TEST")
+        assert.Equal(t, r.ASNumbers[0], 64496)
+        assert.Equal(t, r.ASNumbers[1], 64497)
+        assert.Equal(t, r.ASNumbers[2], 64498)
+}
+
+const errorFilev4 = `
+2020-02-12 19:43:23 <INFO> 64496:1:1500:v4:Testnet: 192.0.2.0/24 from 192.0.2.1 (path 64496 64497 64497 64497 64499): AS64499 not member of IRR as-set object! Dropping.
+2020-02-12 19:43:23 <INFO> 64496:1:1500:v4:Testnet: 198.51.100.0/24 from 192.0.2.1: bgp_path(path 64496 64497 64498 64498 64499) matches pdb_never_via_route_servers_ASNs! Dropping.
+2020-02-12 19:43:23 <INFO> 64496:1:1500:v4:Testnet: 192.0.2.0/26 from 192.0.2.1 (path 64496): RPKI ROA_INVALID! Dropping.
+`
+
+const errorFilev6 = `
+2020-02-12 19:43:23 <INFO> 64496:1:1500:v6:Testnet: 2001:db8::/16 from 2001:db8::1: matches bogon_prefixes! Dropping.
+2020-02-12 19:43:23 <INFO> 64496:1:1500:v6:Testnet: 2001:db8::/24 from 2001:db8::1: bgp_path(path 64496 64497 64497 64497 64497 64497 64497 64497 64497 64498) matches pdb_never_via_route_servers_ASNs! Dropping.
+2020-02-12 19:43:23 <INFO> 64496:1:1500:v6:Testnet: 2001:db8::/32 from 2001:db8::1 (path 64496 64497 64498 64498 64499): AS64499 not member of IRR as-set object! Dropping.
+`
+
+// Last line intentionally not parsable
+const errorFilev4j = `
+2020-02-12 19:43:23 <INFO> 64496:1:9000:v4:Testnet: 192.0.2.0/24 from 192.0.2.1: bgp_path(path 64496 64498 { 75757 }) matches bogon_ASNs! Dropping.
+2020-02-12 19:43:23 <INFO> 64496:1:9000:v4:Testnet: 198.51.100.0/24 from 192.0.2.1: matches bogon_prefixes! Dropping.
+2 20-02-12 19:43:23 <INFO> 64496:1:9000:v4:Testnet: 192.0.2.0/26 from 192.0.2.1: matches bogon_prefixes! Dropping.
+`
+
+// Last line intentionally not parsable
+const errorFilev6j = `
+2020-02-12 19:43:23 <INFO> 64496:1:9000:v6:Testnet: 2001:db8::/32 from 2001:db8::1 (path 64496 64497 64499): no IRR route object found! Transit_dropping.
+2020-02-12 19:43:23 <INFO> 64496:1:9000:v6:Testnet: 2001:db8::/36 from 2001:db8::1 (path 64496 64498 64499): no IRR route object found! Transit_dropping.
+2020-02-12 19:43:23 <INFO> 64496:1:9000:v6:Testnet: 2001:db8::/48 from 2001:db8::1 (path 64496 64498 64498 64498 64499): RPKI ROA_INVALID! Transit_dropping.
+2 20-02-12 19:43:23 <INFO> 64496:1:9000:v6:Testnet: 2001:db8::/48 from 2001:db8::1 (path 64496 64498 64498 64498 64499): RPKI ROA_INVALID! Transit_dropping.
+`
+
+func TestParsingErrorFile(t *testing.T) {
+        e := parseErrorFiles(
+                strings.Split(errorFilev4, "\n"),
+                strings.Split(errorFilev6, "\n"),
+                strings.Split(errorFilev4j, "\n"),
+                strings.Split(errorFilev6j, "\n"))
+
+        v4t := []struct {
+                Timestamp   time.Time
+                ASN         int
+                MTU         int
+                Version     IPVersion
+                NetworkName string
+                Network     net.IPNet
+                Router      net.IP
+                Path        []int
+                Message     string
+        }{
+                {testDate, 64496, 1500, IPv4, "Testnet", parseCidr("192.0.2.0/24"), net.ParseIP("192.0.2.1"), []int{64496, 64497, 64497, 64497, 64499}, "AS64499 not member of IRR as-set object! Dropping."},
+                {testDate, 64496, 1500, IPv4, "Testnet", parseCidr("198.51.100.0/24"), net.ParseIP("192.0.2.1"), []int{64496, 64497, 64498, 64498, 64499}, "matches pdb_never_via_route_servers_ASNs! Dropping."},
+                {testDate, 64496, 1500, IPv4, "Testnet", parseCidr("192.0.2.0/26"), net.ParseIP("192.0.2.1"), []int{64496}, "RPKI ROA_INVALID! Dropping."},
+        }
+
+        for i, tv := range v4t {
+                assert.EqualValues(t, tv, e.IPv4.Records[i])
+        }
+
+        v6t := []struct {
+                Timestamp   time.Time
+                ASN         int
+                MTU         int
+                Version     IPVersion
+                NetworkName string
+                Network     net.IPNet
+                Router      net.IP
+                Path        []int
+                Message     string
+        }{
+                {testDate, 64496, 1500, IPv6, "Testnet", parseCidr("2001:db8::/16"), net.ParseIP("2001:db8::1"), []int{}, "matches bogon_prefixes! Dropping."},
+                {testDate, 64496, 1500, IPv6, "Testnet", parseCidr("2001:db8::/24"), net.ParseIP("2001:db8::1"), []int{64496, 64497, 64497, 64497, 64497, 64497, 64497, 64497, 64497, 64498}, "matches pdb_never_via_route_servers_ASNs! Dropping."},
+                {testDate, 64496, 1500, IPv6, "Testnet", parseCidr("2001:db8::/32"), net.ParseIP("2001:db8::1"), []int{64496, 64497, 64498, 64498, 64499}, "AS64499 not member of IRR as-set object! Dropping."},
+        }
+
+        for i, tv := range v6t {
+                assert.EqualValues(t, tv, e.IPv6.Records[i])
+        }
+
+        v4jt := []struct {
+                Timestamp   time.Time
+                ASN         int
+                MTU         int
+                Version     IPVersion
+                NetworkName string
+                Network     net.IPNet
+                Router      net.IP
+                Path        []int
+                Message     string
+        }{
+                {testDate, 64496, 9000, IPv4, "Testnet", parseCidr("192.0.2.0/24"), net.ParseIP("192.0.2.1"), []int{64496, 64498, 75757}, "matches bogon_ASNs! Dropping."},
+                {testDate, 64496, 9000, IPv4, "Testnet", parseCidr("198.51.100.0/24"), net.ParseIP("192.0.2.1"), []int{}, "matches bogon_prefixes! Dropping."},
+        }
+
+        for i, tv := range v4jt {
+                assert.EqualValues(t, tv, e.IPv4Jumbo.Records[i])
+        }
+
+        badLinev4j := "2 20-02-12 19:43:23 <INFO> 64496:1:9000:v4:Testnet: 192.0.2.0/26 from 192.0.2.1: matches bogon_prefixes! Dropping."
+        assert.Equal(t, badLinev4j, e.IPv4Jumbo.UnparsableLines[0])
+
+        v6jt := []struct {
+                Timestamp   time.Time
+                ASN         int
+                MTU         int
+                Version     IPVersion
+                NetworkName string
+                Network     net.IPNet
+                Router      net.IP
+                Path        []int
+                Message     string
+        }{
+                {testDate, 64496, 9000, IPv6, "Testnet", parseCidr("2001:db8::/32"), net.ParseIP("2001:db8::1"), []int{64496, 64497, 64499}, "no IRR route object found! Transit_dropping."},
+                {testDate, 64496, 9000, IPv6, "Testnet", parseCidr("2001:db8::/36"), net.ParseIP("2001:db8::1"), []int{64496, 64498, 64499}, "no IRR route object found! Transit_dropping."},
+                {testDate, 64496, 9000, IPv6, "Testnet", parseCidr("2001:db8::/48"), net.ParseIP("2001:db8::1"), []int{64496, 64498, 64498, 64498, 64499}, "RPKI ROA_INVALID! Transit_dropping."},
+        }
+
+        for i, tv := range v6jt {
+                assert.EqualValues(t, tv, e.IPv6Jumbo.Records[i])
+        }
+
+        badLinev6j := "2 20-02-12 19:43:23 <INFO> 64496:1:9000:v6:Testnet: 2001:db8::/48 from 2001:db8::1 (path 64496 64498 64498 64498 64499): RPKI ROA_INVALID! Transit_dropping."
+        assert.Equal(t, badLinev6j, e.IPv6Jumbo.UnparsableLines[0])
+}
diff --git a/six/participant.go b/six/participant.go
new file mode 100644
index 0000000..e8150bb
--- /dev/null
+++ b/six/participant.go
@@ -0,0 +1,224 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// Copyright (C) 2020 Michael Crute <mike@crute.us>. All rights reserved.
+//
+// Use of this source code is governed by a license that can be found in the
+// LICENSE file.
+
+package six
+
+import (
+        "net"
+        "time"
+)
+
+// IP protocol version number
+type IPVersion int
+
+const (
+        IPv6 IPVersion = 6
+        IPv4           = 4
+)
+
+// IPv4 and IPv6 union type, contains a full network for IPv4 and IPv6
+// addresses
+type Addresses struct {
+        IPv4 *net.IPNet
+        IPv6 *net.IPNet
+}
+
+// IRR statistical data. Contains the counts of various IRR data for a
+// participant.
+type IRRData struct {
+        PrefixCount int
+        ASNCount    int
+        ASSetCount  int
+}
+
+// Set of prefixes, optionally with an AS-SET name that a participant has
+// registered with the exchange.
+type PrefixSet struct {
+        Timestamp time.Time
+        ASSet     *string
+        Prefixes  []net.IPNet
+}
+
+// Set of AS numbers with an AS-SET that the participant has registered with
+// the exchange.
+type ASSet struct {
+        Timestamp time.Time
+        Name      string
+        ASNumbers []int
+}
+
+// Set of ROA record summaries that have been parsed from the raw ROA data for
+// a participant.
+type ROASet struct {
+        Timestamp time.Time
+        ROAS      []ROA
+}
+
+// Individual ROA summary
+type ROA struct {
+        TrustAnchor string
+        ASN         int
+        MaxLength   int
+        Prefix      net.IPNet
+}
+
+// A SIX participant is a record of an organization's connection to the Seattle
+// Internet Exchange. It contains information about their connect, the prefixes
+// and ASes that they have registered with the exchange, and their usage of the
+// route server.
+//
+// Not all data exists for all participants, and the data that does exist isn't
+// always in a nice clean format. The parsers attempt to make sense of whatever
+// is available but some data may be missing or inconsistent.
+//
+// The default contains summary data for the participant and more detailed data
+// can be fetched with the methods attached to this struct as well as to the
+// RouteServer structs, if the participant is using the route server.
+type SIXParticipant struct {
+        Organization           string
+        URL                    string
+        ASN                    int
+        Speed                  int    // Connection speed in Mbit/s
+        Switch                 string // Connected Switch or Location
+        Contact                string // Contact Email
+        Comment                string
+        IsConnected            bool
+        IsVoter                bool
+        Update                 *time.Time
+        Options                []string // Currently: IPv6 and MTU9k
+        PeeringPolicy          string
+        ROACount               int
+        PeeringDBPrefixCountv4 int
+        PeeringDBPrefixCountv6 int
+        Addresses              Addresses
+        JumboAddresses         *Addresses
+        IRRv4                  IRRData
+        IRRv6                  IRRData
+        RouteServer2           *RouteServer
+        RouteServer3           *RouteServer
+}
+
+// Get the set of prefixes that the participant has registered.
+//
+// This does an HTTP fetch to get the detailed file.
+func (p *SIXParticipant) GetPrefixes(ip IPVersion) (*PrefixSet, error) {
+        return fetchParsePrefixList(p.ASN, ip, false)
+}
+
+// Get the prefix to AS associations that the participant has registered.
+//
+// This does an HTTP fetch to get the detailed file.
+func (p *SIXParticipant) GetASPrefixes(ip IPVersion) (*PrefixSet, error) {
+        return fetchParsePrefixList(p.ASN, ip, true)
+}
+
+// Get the AS sets that the participant has registered
+//
+// This does an HTTP fetch to get the detailed file.
+func (p *SIXParticipant) GetASSet(ip IPVersion) (*ASSet, error) {
+        return fetchParseASSet(p.ASN, ip)
+}
+
+// Get the ROA set and more detailed records for the ROAs that the participant
+// has registered. This does not fetch the raw ROAs, just the summary that the
+// exchange has computed.
+//
+// This does an HTTP fetch to get the detailed file.
+func (p *SIXParticipant) GetROASet() (*ROASet, error) {
+        return fetchParseROAFile(p.ASN)
+}
+
+// List of lines from the file containing route data dumped from the route
+// server
+type RouteFile struct {
+        Timestamp time.Time
+        Lines     []string
+}
+
+// Lists of errors that the route server has exported. These are parsed for
+// more details if possible, but if that fails the attached ErrorRecords object
+// contains a list of un-parsable lines for consumption.
+type Errors struct {
+        IPv4      *ErrorRecords
+        IPv6      *ErrorRecords
+        IPv4Jumbo *ErrorRecords
+        IPv6Jumbo *ErrorRecords
+}
+
+// List of error records for route server errors. Also contains a list of lines
+// that could not be parsed by the parser.
+type ErrorRecords struct {
+        Records         []ErrorRecord
+        UnparsableLines []string
+}
+
+// Create a new ErrorRecords struct
+func NewErrorRecords() *ErrorRecords {
+        return &ErrorRecords{
+                Records:         []ErrorRecord{},
+                UnparsableLines: []string{},
+        }
+}
+
+// Contains the parsed data for a route server error.
+type ErrorRecord struct {
+        Timestamp   time.Time
+        ASN         int
+        MTU         int
+        Version     IPVersion
+        NetworkName string
+        Network     net.IPNet
+        Router      net.IP
+        Path        []int
+        Message     string
+}
+
+// Data about the participant's connection to a route server. If the
+// participant is making use of the route servers this will always contain some
+// basic statistics about their connection. More detailed information can be
+// obtained by calling the methods attached to this struct.
+type RouteServer struct {
+        Number    int
+        IPv4      RouteServerStats
+        IPv6      RouteServerStats
+        IPv4Jumbo RouteServerStats
+        IPv6Jumbo RouteServerStats
+        asn       int
+}
+
+// Route server statistics. Contains the counts of various types of route
+// server entries.
+type RouteServerStats struct {
+        Prefixes      int
+        Errors        int
+        TransitErrors int
+}
+
+// Gets the list of routes being advertised by the participant. Note that this
+// file is the raw lines from the route server and no attempt has been made to
+// parse these lines. The lines are in BIRD format.
+//
+// This does an HTTP fetch to get the detailed file.
+func (s *RouteServer) GetRoutes(ip IPVersion, jumbo bool) (*RouteFile, error) {
+        return fetchParseRoutes(s.Number, s.asn, ip, jumbo)
+}
+
+// Gets the errors returned by the route server for all IP protocols and all
+// VLANs to which the participant is connected. If the participant is using
+// multiple route servers, this data is scoped to the current route server.
+//
+// This does an HTTP fetch to get the detailed file.
+func (s *RouteServer) GetErrors() (*Errors, error) {
+        return fetchParseRSErrors(s.Number, s.asn, false), nil
+}
+
+// Get a list of transit errors from the route server. Otherwise return value
+// and behavior is identical to GetErrors.
+//
+// This does an HTTP fetch to get the detailed file.
+func (s *RouteServer) GetTransitErrors() (*Errors, error) {
+        return fetchParseRSErrors(s.Number, s.asn, true), nil
+}
diff --git a/six/participant_builder.go b/six/participant_builder.go
new file mode 100644
index 0000000..f18a6d1
--- /dev/null
+++ b/six/participant_builder.go
@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// Copyright (C) 2020 Michael Crute <mike@crute.us>. All rights reserved.
+//
+// Use of this source code is governed by a license that can be found in the
+// LICENSE file.
+
+package six
+
+import (
+        "fmt"
+        "strings"
+)
+
+// Create a new SIXParticipant struct from a map of data that was parsed from
+// the participant CSV file. This assumes the column headers from that CSV file
+// so it will not work with the other data formats avaiable.
+//
+// This uses the CSV file because it's both the most rich source of data and
+// the easiest to parse.
+func NewSIXParticipantFromData(d map[string]string) *SIXParticipant {
+        r := &SIXParticipant{
+                Organization:           d["Organization"],
+                URL:                    d["URL"],
+                ASN:                    mustParseInt(d["ASN"]),
+                Speed:                  mustParseInt(d["Speed"]),
+                Switch:                 d["Switch"],
+                Contact:                d["Contact"],
+                Comment:                d["Comment"],
+                IsConnected:            parseYesNo(d["Conn?"]),
+                IsVoter:                parseYesNo(d["Voter?"]),
+                Update:                 mustParseTime(d["Update"]),
+                Options:                strings.Split(d["Options"], " "),
+                PeeringPolicy:          d["Policy"],
+                ROACount:               mustParseInt(d["rpki:roa"]),
+                PeeringDBPrefixCountv4: mustParseInt(d["pdb:v4"]),
+                PeeringDBPrefixCountv6: mustParseInt(d["pdb:v6"]),
+                Addresses: Addresses{
+                        IPv4: parseIPNetFromCIDR(d["IPv4"]),
+                        IPv6: parseIPNetFromCIDR(d["IPv6"]),
+                },
+                IRRv4: IRRData{
+                        PrefixCount: mustParseInt(d["irr:p4"]),
+                        ASNCount:    mustParseInt(d["irr:a4"]),
+                        ASSetCount:  mustParseInt(d["irr:ap4"]),
+                },
+                IRRv6: IRRData{
+                        PrefixCount: mustParseInt(d["irr:p6"]),
+                        ASNCount:    mustParseInt(d["irr:a6"]),
+                        ASSetCount:  mustParseInt(d["irr:ap6"]),
+                },
+                RouteServer2: getRSData(2, d),
+                RouteServer3: getRSData(3, d),
+        }
+
+        // Not all participants use the MTU9k VLAN
+        ja4 := parseIPNetFromCIDR(d["Jumbo IPv4"])
+        ja6 := parseIPNetFromCIDR(d["Jumbo IPv6"])
+        if ja4 != nil && ja6 != nil {
+                r.JumboAddresses = &Addresses{IPv4: ja4, IPv6: ja6}
+        }
+
+        return r
+}
+
+func getRSData(server int, d map[string]string) *RouteServer {
+        // Extract all the data and determine if it's all empty strings, if so then
+        // the participant isn't using the route server. If any data is not empty
+        // then they are. Do integer conversion afterward to avoid ambiguity about
+        // zero vs empty string.
+        pd := []string{
+                d[fmt.Sprintf("rs%d:v4", server)],
+                d[fmt.Sprintf("err%d:v4", server)],
+                d[fmt.Sprintf("xerr%d:v4", server)],
+                d[fmt.Sprintf("rs%d:v6", server)],
+                d[fmt.Sprintf("err%d:v6", server)],
+                d[fmt.Sprintf("xerr%d:v6", server)],
+                d[fmt.Sprintf("rs%d:v4j", server)],
+                d[fmt.Sprintf("err%d:v4j", server)],
+                d[fmt.Sprintf("xerr%d:v4j", server)],
+                d[fmt.Sprintf("rs%d:v6j", server)],
+                d[fmt.Sprintf("err%d:v6j", server)],
+                d[fmt.Sprintf("xerr%d:v6j", server)],
+        }
+
+        if allEmpty(pd) {
+                return nil
+        }
+
+        return &RouteServer{
+                Number: server,
+                asn:    mustParseInt(d["ASN"]),
+                IPv4: RouteServerStats{
+                        Prefixes:      mustParseInt(pd[0]),
+                        Errors:        mustParseInt(pd[1]),
+                        TransitErrors: mustParseInt(pd[2]),
+                },
+                IPv6: RouteServerStats{
+                        Prefixes:      mustParseInt(pd[3]),
+                        Errors:        mustParseInt(pd[4]),
+                        TransitErrors: mustParseInt(pd[5]),
+                },
+                IPv4Jumbo: RouteServerStats{
+                        Prefixes:      mustParseInt(pd[6]),
+                        Errors:        mustParseInt(pd[7]),
+                        TransitErrors: mustParseInt(pd[8]),
+                },
+                IPv6Jumbo: RouteServerStats{
+                        Prefixes:      mustParseInt(pd[9]),
+                        Errors:        mustParseInt(pd[10]),
+                        TransitErrors: mustParseInt(pd[11]),
+                },
+        }
+}