diff --git a/Gopkg.lock b/Gopkg.lock index 4d6be5a0..621d6366 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -2,30 +2,39 @@ [[projects]] + digest = "1:bf42be3cb1519bf8018dfd99720b1005ee028d947124cab3ccf965da59381df6" name = "github.com/Microsoft/go-winio" packages = ["."] + pruneopts = "UT" revision = "7da180ee92d8bd8bb8c37fc560e673e6557c392f" version = "v0.4.7" [[projects]] + digest = "1:d1665c44bd5db19aaee18d1b6233c99b0b9a986e8bccb24ef54747547a48027f" name = "github.com/PuerkitoBio/purell" packages = ["."] + pruneopts = "UT" revision = "0bcb03f4b4d0a9428594752bd2a3b9aa0a9d4bd4" version = "v1.1.0" [[projects]] branch = "master" + digest = "1:c739832d67eb1e9cc478a19cc1a1ccd78df0397bf8a32978b759152e205f644b" name = "github.com/PuerkitoBio/urlesc" packages = ["."] + pruneopts = "UT" revision = "de5bf2ad457846296e2031421a34e2568e304e35" [[projects]] branch = "master" + digest = "1:9fd3a6ab34bb103ba228eefd044d3f9aa476237ea95a46d12e8cccd3abf3fea2" name = "github.com/armon/go-radix" packages = ["."] + pruneopts = "UT" revision = "1fca145dffbcaa8fe914309b1ec0cfc67500fe61" [[projects]] + digest = "1:220c8689d516e36f763897aaee8db751f30cbc7f2b87536e44555019796ef191" name = "github.com/aws/aws-sdk-go" packages = [ "aws", @@ -54,18 +63,22 @@ "private/protocol/rest", "private/protocol/xml/xmlutil", "service/ec2", - "service/sts" + "service/sts", ] + pruneopts = "UT" revision = "9b0098a71f6d4d473a26ec8ad3c2feaac6eb1da6" version = "v1.13.32" [[projects]] branch = "master" + digest = "1:d6afaeed1502aa28e80a4ed0981d570ad91b2579193404256ce672ed0a609e0d" name = "github.com/beorn7/perks" packages = ["quantile"] + pruneopts = "UT" revision = "3a771d992973f24aa725d07868b467d1ddfceafb" [[projects]] + digest = "1:23cd6ae7715a846f8f0580e89158b9d15f95b0b2dfeae2d612123ed6df31c47a" name = "github.com/containernetworking/cni" packages = [ "libcni", @@ -78,39 +91,49 @@ "pkg/utils/hwaddr", "pkg/version", "plugins/ipam/host-local/backend", - "plugins/ipam/host-local/backend/allocator" + "plugins/ipam/host-local/backend/allocator", ] + pruneopts = "UT" revision = "137b4975ecab6e1f0c24c1e3c228a50a3cfba75e" version = "v0.5.2" [[projects]] + digest = "1:df4af3a8e15cd72b068b8d898598001935edce4eac4eb5a3d7fd906036123ff4" name = "github.com/coreos/go-iptables" packages = ["iptables"] + pruneopts = "UT" revision = "259c8e6a4275d497442c721fa52204d7a58bde8b" version = "v0.2.0" [[projects]] + digest = "1:a2c1d0e43bd3baaa071d1b9ed72c27d78169b2b269f71c105ac4ba34b1be4a39" name = "github.com/davecgh/go-spew" packages = ["spew"] + pruneopts = "UT" revision = "346938d642f2ec3594ed81d874461961cd0faa76" version = "v1.1.0" [[projects]] branch = "master" + digest = "1:8583eab935e3d99d3a7ac489cd2ee7c8e95eecd7c64ab1fc8382746dacaf8563" name = "github.com/dgryski/go-farm" packages = ["."] + pruneopts = "UT" revision = "2de33835d10275975374b37b2dcfd22c9020a1f5" [[projects]] + digest = "1:4189ee6a3844f555124d9d2656fe7af02fca961c2a9bad9074789df13a0c62e0" name = "github.com/docker/distribution" packages = [ "digestset", - "reference" + "reference", ] + pruneopts = "UT" revision = "1e2f10eb65743fed02f573d31a4587de09afb20e" [[projects]] branch = "master" + digest = "1:d40cef2b20331a3a337ff6872f39c470ed5cd4800919f0ef4847403b3df3b172" name = "github.com/docker/docker" packages = [ "api", @@ -129,169 +152,215 @@ "api/types/time", "api/types/versions", "api/types/volume", - "client" + "client", ] + pruneopts = "UT" revision = "5c2e6064a1c5cb816081958e5a7079bc6b474940" [[projects]] + digest = "1:b6b5c3e8da0fb8073cd2886ba249a40f4402b4391ca6eba905a142cceea97a12" name = "github.com/docker/go-connections" packages = [ "nat", "sockets", - "tlsconfig" + "tlsconfig", ] + pruneopts = "UT" revision = "3ede32e2033de7505e6500d6c868c2b9ed9f169d" version = "v0.3.0" [[projects]] + digest = "1:6f82cacd0af5921e99bf3f46748705239b36489464f4529a1589bc895764fb18" name = "github.com/docker/go-units" packages = ["."] + pruneopts = "UT" revision = "47565b4f722fb6ceae66b95f853feed578a4a51c" version = "v0.3.3" [[projects]] + digest = "1:6b20706ea25f78700bfd6eda620a95233c6340acb53d295553e290c626c809c7" name = "github.com/docker/libnetwork" packages = ["ipvs"] + pruneopts = "UT" revision = "14aa49f99093e1a22e65155b641103762911db8d" [[projects]] + digest = "1:975a4480c40f2d0b95e1f83d3ec1aa29a2774e80179e08a9a4ba2aab86721b23" name = "github.com/eapache/channels" packages = ["."] + pruneopts = "UT" revision = "47238d5aae8c0fefd518ef2bee46290909cf8263" version = "v1.1.0" [[projects]] + digest = "1:444b82bfe35c83bbcaf84e310fb81a1f9ece03edfed586483c869e2c046aef69" name = "github.com/eapache/queue" packages = ["."] + pruneopts = "UT" revision = "44cc805cf13205b55f69e14bcb69867d1ae92f98" version = "v1.1.0" [[projects]] + digest = "1:d91a89491d49259e41fb09c3a3d42f740d84edee064d8ecede0d64b388bfad71" name = "github.com/emicklei/go-restful" packages = [ ".", - "log" + "log", ] + pruneopts = "UT" revision = "26b41036311f2da8242db402557a0dbd09dc83da" version = "v2.6.0" [[projects]] + digest = "1:ddab18e89cf46e40707b89dbe3835b4a591b0ea298e1035eefa84002aa9a4b4e" name = "github.com/emicklei/go-restful-swagger12" packages = ["."] + pruneopts = "UT" revision = "dcef7f55730566d41eae5db10e7d6981829720f6" version = "1.0.1" [[projects]] + digest = "1:abeb38ade3f32a92943e5be54f55ed6d6e3b6602761d74b4aab4c9dd45c18abd" name = "github.com/fsnotify/fsnotify" packages = ["."] + pruneopts = "UT" revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9" version = "v1.4.7" [[projects]] + digest = "1:2cd7915ab26ede7d95b8749e6b1f933f1c6d5398030684e6505940a10f31cfda" name = "github.com/ghodss/yaml" packages = ["."] + pruneopts = "UT" revision = "0ca9ea5df5451ffdf184b4428c902747c2c11cd7" version = "v1.0.0" [[projects]] + digest = "1:ad12727c184fc7e33768f5fe239d8f767a3b60264541067ac2f23b9aca013e06" name = "github.com/go-ini/ini" packages = ["."] + pruneopts = "UT" revision = "ace140f73450505f33e8b8418216792275ae82a7" version = "v1.35.0" [[projects]] branch = "master" + digest = "1:2997679181d901ac8aaf4330d11138ecf3974c6d3334995ff36f20cbd597daf8" name = "github.com/go-openapi/jsonpointer" packages = ["."] + pruneopts = "UT" revision = "3a0015ad55fa9873f41605d3e8f28cd279c32ab2" [[projects]] branch = "master" + digest = "1:1ae3f233d75a731b164ca9feafd8ed646cbedf1784095876ed6988ce8aa88b1f" name = "github.com/go-openapi/jsonreference" packages = ["."] + pruneopts = "UT" revision = "3fb327e6747da3043567ee86abd02bb6376b6be2" [[projects]] branch = "master" + digest = "1:5ef2c99a4cac00088f7092ec23f33aadef74ef59b75be43d08a0c9f119bac073" name = "github.com/go-openapi/spec" packages = ["."] + pruneopts = "UT" revision = "370d9e047557906322be8396e77cb0376be6cb96" [[projects]] branch = "master" + digest = "1:ec7e31653be60f0add6fb60bdc91c21056b9e7bc870cfdcea18ebc45e4dfd916" name = "github.com/go-openapi/swag" packages = ["."] + pruneopts = "UT" revision = "811b1089cde9dad18d4d0c2d09fbdbf28dbd27a5" [[projects]] + digest = "1:a7534feda0f15b5fd691e59e4fb6b7547e27df4b415a62e02c7cb71b3439c1b1" name = "github.com/gogo/protobuf" packages = [ "proto", - "sortkeys" + "sortkeys", ] + pruneopts = "UT" revision = "1adfc126b41513cc696b209667c8656ea7aac67c" version = "v1.0.0" [[projects]] branch = "master" + digest = "1:1ba1d79f2810270045c328ae5d674321db34e3aae468eb4233883b473c5c0467" name = "github.com/golang/glog" packages = ["."] + pruneopts = "UT" revision = "23def4e6c14b4da8ac2ed8007337bc5eb5007998" [[projects]] branch = "master" + digest = "1:0f56223de1ca49228034f96a18d3659415404c986426290b9761935f02894755" name = "github.com/golang/protobuf" packages = [ "proto", "ptypes", "ptypes/any", "ptypes/duration", - "ptypes/timestamp" + "ptypes/timestamp", ] + pruneopts = "UT" revision = "e09c5db296004fbe3f74490e84dcd62c3c5ddb1b" [[projects]] branch = "master" + digest = "1:9887333bbef17574b1db5f9893ea137ac44107235d624408a3ac9e0b98fbb2cb" name = "github.com/google/btree" packages = ["."] + pruneopts = "UT" revision = "e89373fe6b4a7413d7acd6da1725b83ef713e6e4" [[projects]] branch = "master" + digest = "1:3ee90c0d94da31b442dde97c99635aaafec68d0b8a3c12ee2075c6bdabeec6bb" name = "github.com/google/gofuzz" packages = ["."] + pruneopts = "UT" revision = "24818f796faf91cd76ec7bddd72458fbced7a6c1" [[projects]] + digest = "1:5e031a35b76ee001fa9ca9d598298054a123d080e00d13a8dafcfc5e3ecd5b58" name = "github.com/googleapis/gnostic" packages = [ "OpenAPIv2", "compiler", - "extensions" + "extensions", ] + pruneopts = "UT" revision = "ee43cbb60db7bd22502942cccbc39059117352ab" version = "v0.1.0" [[projects]] branch = "master" + digest = "1:86c1210529e69d69860f2bb3ee9ccce0b595aa3f9165e7dd1388e5c612915888" name = "github.com/gregjones/httpcache" packages = [ ".", - "diskcache" + "diskcache", ] + pruneopts = "UT" revision = "9cad4c3443a7200dd6400aef47183728de563a38" [[projects]] branch = "master" + digest = "1:cf296baa185baae04a9a7004efee8511d08e2f5f51d4cbe5375da89722d681db" name = "github.com/hashicorp/golang-lru" packages = [ ".", - "simplelru" + "simplelru", ] + pruneopts = "UT" revision = "0fb14efe8c47ae851c0034ed7a448854d3d34cf3" [[projects]] branch = "master" + digest = "1:a361611b8c8c75a1091f00027767f7779b29cb37c456a71b8f2604c88057ab40" name = "github.com/hashicorp/hcl" packages = [ ".", @@ -303,96 +372,124 @@ "hcl/token", "json/parser", "json/scanner", - "json/token" + "json/token", ] + pruneopts = "UT" revision = "ef8a98b0bbce4a65b5aa4c368430a80ddc533168" [[projects]] branch = "master" + digest = "1:0778dc7fce1b4669a8bfa7ae506ec1f595b6ab0f8989c1c0d22a8ca1144e9972" name = "github.com/howeyc/gopass" packages = ["."] + pruneopts = "UT" revision = "bf9dde6d0d2c004a008c27aaee91170c786f6db8" [[projects]] + digest = "1:b39dba8363bf11da3cddcc31c5a9c39f17fba8a5317ae0836ea4530bae3b4866" name = "github.com/imdario/mergo" packages = ["."] + pruneopts = "UT" revision = "9d5f1277e9a8ed20c3684bda8fde67c05628518c" version = "v0.3.4" [[projects]] + digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be" name = "github.com/inconshreveable/mousetrap" packages = ["."] + pruneopts = "UT" revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75" version = "v1.0" [[projects]] + digest = "1:ce530152667dc8ba823a586c1c81175aff2c4e15500520883a2727d0ed17c6f1" name = "github.com/influxdata/influxdb" packages = [ "client/v2", "models", - "pkg/escape" + "pkg/escape", ] + pruneopts = "UT" revision = "02d7d4f043b34ecb4e9b2dbec298c6f9450c2a32" version = "v1.5.2" [[projects]] + digest = "1:e22af8c7518e1eab6f2eab2b7d7558927f816262586cd6ed9f349c97a6c285c4" name = "github.com/jmespath/go-jmespath" packages = ["."] + pruneopts = "UT" revision = "0b12d6b5" [[projects]] + digest = "1:b1d4df033414c1a0d85fa7037b9aaf03746314811c860a95ea2d5fd481cd6c35" name = "github.com/json-iterator/go" packages = ["."] + pruneopts = "UT" revision = "ca39e5af3ece67bbcda3d0f4f56a8e24d9f2dad4" version = "1.1.3" [[projects]] + digest = "1:190ff84d9b2ed6589088f178cba8edb4b8ecb334df4572421fb016be1ac20463" name = "github.com/juju/ratelimit" packages = ["."] + pruneopts = "UT" revision = "59fac5042749a5afb9af70e813da1dd5474f0167" version = "1.0.1" [[projects]] + digest = "1:5149009cc36718234a9ad2896b04b04716808b8d72143b5687c0a15b53132b27" name = "github.com/magiconair/properties" packages = ["."] + pruneopts = "UT" revision = "c3beff4c2358b44d0493c7dda585e7db7ff28ae6" version = "v1.7.6" [[projects]] branch = "master" + digest = "1:ada518b8c338e10e0afa443d84671476d3bd1d926e13713938088e8ddbee1a3e" name = "github.com/mailru/easyjson" packages = [ "buffer", "jlexer", - "jwriter" + "jwriter", ] + pruneopts = "UT" revision = "8b799c424f57fa123fc63a99d6383bc6e4c02578" [[projects]] + digest = "1:5985ef4caf91ece5d54817c11ea25f182697534f8ae6521eadcd628c142ac4b6" name = "github.com/matttproud/golang_protobuf_extensions" packages = ["pbutil"] + pruneopts = "UT" revision = "3247c84500bff8d9fb6d579d800f20b3e091582c" version = "v1.0.0" [[projects]] branch = "master" + digest = "1:2514da1e59c0a936d8c1e0fbf5592267a3c5893eb4555ce767bb54d149e9cf6e" name = "github.com/mitchellh/mapstructure" packages = ["."] + pruneopts = "UT" revision = "00c29f56e2386353d58c599509e8dc3801b0d716" [[projects]] + digest = "1:33422d238f147d247752996a26574ac48dcf472976eda7f5134015f06bf16563" name = "github.com/modern-go/concurrent" packages = ["."] + pruneopts = "UT" revision = "bacd9c7ef1dd9b15be4a9909b8ac7a4e313eec94" version = "1.0.3" [[projects]] + digest = "1:d711dfcf661439f1ef0b202a02e8a1ff4deac48f26f34253520dcdbecbd7c5f1" name = "github.com/modern-go/reflect2" packages = ["."] + pruneopts = "UT" revision = "1df9eeb2bb81f327b96228865c5687bc2194af3f" version = "1.0.0" [[projects]] + digest = "1:f4cbb10407f60c0263738e7b219b80ba99516aa9da187f44680d5b29360b3c9f" name = "github.com/onsi/ginkgo" packages = [ ".", @@ -412,12 +509,14 @@ "reporters/stenographer", "reporters/stenographer/support/go-colorable", "reporters/stenographer/support/go-isatty", - "types" + "types", ] + pruneopts = "UT" revision = "9eda700730cba42af70d53180f9dcce9266bc2bc" version = "v1.4.0" [[projects]] + digest = "1:038734db8a70cdd73d4215081b22236e2aed3e65ca0727f6afd0ed839630e738" name = "github.com/onsi/gomega" packages = [ ".", @@ -431,27 +530,33 @@ "matchers/support/goraph/edge", "matchers/support/goraph/node", "matchers/support/goraph/util", - "types" + "types", ] + pruneopts = "UT" revision = "003f63b7f4cff3fc95357005358af2de0f5fe152" version = "v1.3.0" [[projects]] + digest = "1:ee4d4af67d93cc7644157882329023ce9a7bcfce956a079069a9405521c7cc8d" name = "github.com/opencontainers/go-digest" packages = ["."] + pruneopts = "UT" revision = "279bed98673dd5bef374d3b6e4b09e2af76183bf" version = "v1.0.0-rc1" [[projects]] + digest = "1:11db38d694c130c800d0aefb502fb02519e514dc53d9804ce51d1ad25ec27db6" name = "github.com/opencontainers/image-spec" packages = [ "specs-go", - "specs-go/v1" + "specs-go/v1", ] + pruneopts = "UT" revision = "d60099175f88c47cd379c4738d158884749ed235" version = "v1.0.1" [[projects]] + digest = "1:653b5223cbe73bc57d2fc74881c6d77e67a056b7c886973cff7d9522d7c04eab" name = "github.com/osrg/gobgp" packages = [ "api", @@ -465,144 +570,184 @@ "packet/rtr", "server", "table", - "zebra" + "zebra", ] - revision = "d31262de7d91c81ff979b39950d2d859666dfa3f" + pruneopts = "UT" + revision = "v1.33" [[projects]] + digest = "1:7231124c9669dfb54b82ef8b89f2735cf5d5d2529a23c6ac93a8c4b8bbb28b28" name = "github.com/pelletier/go-toml" packages = ["."] + pruneopts = "UT" revision = "acdc4509485b587f5e675510c4f2c63e90ff68a8" version = "v1.1.0" [[projects]] branch = "master" + digest = "1:3bf17a6e6eaa6ad24152148a631d18662f7212e21637c2699bff3369b7f00fa2" name = "github.com/petar/GoLLRB" packages = ["llrb"] + pruneopts = "UT" revision = "53be0d36a84c2a886ca057d34b6aa4468df9ccb4" [[projects]] + digest = "1:0e7775ebbcf00d8dd28ac663614af924411c868dca3d5aa762af0fae3808d852" name = "github.com/peterbourgon/diskv" packages = ["."] + pruneopts = "UT" revision = "5f041e8faa004a95c88a202771f4cc3e991971e6" version = "v2.0.1" [[projects]] + digest = "1:40e195917a951a8bf867cd05de2a46aaf1806c50cf92eebf4c16f78cd196f747" name = "github.com/pkg/errors" packages = ["."] + pruneopts = "UT" revision = "645ef00459ed84a119197bfb8d8205042c6df63d" version = "v0.8.0" [[projects]] + digest = "1:d14a5f4bfecf017cb780bdde1b6483e5deb87e12c332544d2c430eda58734bcb" name = "github.com/prometheus/client_golang" packages = [ "prometheus", - "prometheus/promhttp" + "prometheus/promhttp", ] + pruneopts = "UT" revision = "c5b7fccd204277076155f10851dad72b76a49317" version = "v0.8.0" [[projects]] branch = "master" + digest = "1:32d10bdfa8f09ecf13598324dba86ab891f11db3c538b6a34d1c3b5b99d7c36b" name = "github.com/prometheus/client_model" packages = ["go"] + pruneopts = "UT" revision = "99fa1f4be8e564e8a6b613da7fa6f46c9edafc6c" [[projects]] branch = "master" + digest = "1:e469cd65badf7694aeb44874518606d93c1d59e7735d3754ad442782437d3cc3" name = "github.com/prometheus/common" packages = [ "expfmt", "internal/bitbucket.org/ww/goautoneg", - "model" + "model", ] + pruneopts = "UT" revision = "d0f7cd64bda49e08b22ae8a730aa57aa0db125d6" [[projects]] branch = "master" + digest = "1:570784e0ddbf67f14087c6d8cfb7b999b9c55e75518a755e88cb202566ea8a17" name = "github.com/prometheus/procfs" packages = [ ".", "internal/util", "nfs", - "xfs" + "xfs", ] + pruneopts = "UT" revision = "8b1c2da0d56deffdbb9e48d4414b4e674bd8083e" [[projects]] branch = "master" + digest = "1:ff6b0586c0621a76832cf783eee58cbb9d9795d2ce8acbc199a4131db11c42a9" name = "github.com/satori/go.uuid" packages = ["."] + pruneopts = "UT" revision = "36e9d2ebbde5e3f13ab2e25625fd453271d6522e" [[projects]] + digest = "1:9e9193aa51197513b3abcb108970d831fbcf40ef96aa845c4f03276e1fa316d2" name = "github.com/sirupsen/logrus" packages = ["."] + pruneopts = "UT" revision = "c155da19408a8799da419ed3eeb0cb5db0ad5dbc" version = "v1.0.5" [[projects]] + digest = "1:fe0b7f0c9a5e5511001fe085b0a156b29266012cd984a63e4059a30e84bba03a" name = "github.com/spf13/afero" packages = [ ".", - "mem" + "mem", ] + pruneopts = "UT" revision = "63644898a8da0bc22138abf860edaf5277b6102e" version = "v1.1.0" [[projects]] + digest = "1:516e71bed754268937f57d4ecb190e01958452336fa73dbac880894164e91c1f" name = "github.com/spf13/cast" packages = ["."] + pruneopts = "UT" revision = "8965335b8c7107321228e3e3702cab9832751bac" version = "v1.2.0" [[projects]] branch = "master" + digest = "1:716ae4d5ab908a88497f3b5dd25a3bc270160481bdf7ce0108c3d648fcd5ddf1" name = "github.com/spf13/cobra" packages = ["."] + pruneopts = "UT" revision = "615425954c3b0d9485a7027d4d451fdcdfdee84e" [[projects]] branch = "master" + digest = "1:080e5f630945ad754f4b920e60b4d3095ba0237ebf88dc462eb28002932e3805" name = "github.com/spf13/jwalterweatherman" packages = ["."] + pruneopts = "UT" revision = "7c0cea34c8ece3fbeb2b27ab9b59511d360fb394" [[projects]] + branch = "master" + digest = "1:c1b1102241e7f645bc8e0c22ae352e8f0dc6484b6cb4d132fa9f24174e0119e2" name = "github.com/spf13/pflag" packages = ["."] - revision = "583c0c0531f06d5278b7d917446061adc344b5cd" - version = "v1.0.1" + pruneopts = "UT" + revision = "298182f68c66c05229eb03ac171abe6e309ee79a" [[projects]] branch = "master" + digest = "1:356f83655442b41c5ac8b3fcf04f9a8013449906d04f621826629ce2b91b06a3" name = "github.com/spf13/viper" packages = ["."] + pruneopts = "UT" revision = "8dc2790b029dc41e2b8ff772c63c26adbb1db70d" [[projects]] + digest = "1:2d9d06cb9d46dacfdbb45f8575b39fc0126d083841a29d4fbf8d97708f43107e" name = "github.com/vishvananda/netlink" packages = [ ".", - "nl" + "nl", ] + pruneopts = "UT" revision = "a2ad57a690f3caf3015351d2d6e1c0b95c349752" version = "v1.0.0" [[projects]] branch = "master" + digest = "1:02b1d1b48bf853ea2a9bea029ffe54e3fd7804903a0eda9a78191db8984300d2" name = "github.com/vishvananda/netns" packages = ["."] + pruneopts = "UT" revision = "be1fbeda19366dea804f00efff2dd73a1642fdcc" [[projects]] branch = "master" + digest = "1:3f3a05ae0b95893d90b9b3b5afdb79a9b3d96e4e36e099d841ae602e4aca0da8" name = "golang.org/x/crypto" packages = ["ssh/terminal"] + pruneopts = "UT" revision = "d6449816ce06963d9d136eee5a56fca5b0616e7e" [[projects]] branch = "master" + digest = "1:ee1694164963c184e44f8c675c96a9a0fcaee79f51194f296e937a7f15bee72d" name = "golang.org/x/net" packages = [ "context", @@ -617,20 +762,24 @@ "internal/timeseries", "lex/httplex", "proxy", - "trace" + "trace", ] + pruneopts = "UT" revision = "61147c48b25b599e5b561d2e9c4f3e1ef489ca41" [[projects]] branch = "master" + digest = "1:4d0a3e91e65c614186d6f0e9a65b7a1c0f80ff233634585c6f8eed728fabf4cb" name = "golang.org/x/sys" packages = [ "unix", - "windows" + "windows", ] + pruneopts = "UT" revision = "2281fa97ef7b0c26324634d5a22f04babdac8713" [[projects]] + digest = "1:bb8277a2ca2bcad6ff7f413b939375924099be908cedd1314baa21ecd08df477" name = "golang.org/x/text" packages = [ "collate", @@ -659,18 +808,22 @@ "unicode/cldr", "unicode/norm", "unicode/rangetable", - "width" + "width", ] + pruneopts = "UT" revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0" version = "v0.3.0" [[projects]] branch = "master" + digest = "1:cd018653a358d4b743a9d3bee89e825521f2ab2f2ec0770164bf7632d8d73ab7" name = "google.golang.org/genproto" packages = ["googleapis/rpc/status"] + pruneopts = "UT" revision = "7fd901a49ba6a7f87732eb344f6e3c5b19d1b200" [[projects]] + digest = "1:f47fb9bd1a9173285be23a1a1342e019abddfd787216e7f2c555ddba837e98ce" name = "google.golang.org/grpc" packages = [ ".", @@ -695,31 +848,39 @@ "stats", "status", "tap", - "transport" + "transport", ] + pruneopts = "UT" revision = "d11072e7ca9811b1100b80ca0269ac831f06d024" version = "v1.11.3" [[projects]] + digest = "1:2d1fbdc6777e5408cabeb02bf336305e724b925ff4546ded0fa8715a7267922a" name = "gopkg.in/inf.v0" packages = ["."] + pruneopts = "UT" revision = "d2d2541c53f18d2a059457998ce2876cc8e67cbf" version = "v0.9.1" [[projects]] branch = "v2" + digest = "1:5bb148b78468350091db2ffbb2370f35cc6dcd74d9378a31b1c7b86ff7528f08" name = "gopkg.in/tomb.v2" packages = ["."] + pruneopts = "UT" revision = "d5d1b5820637886def9eef33e03a27a9f166942c" [[projects]] + digest = "1:342378ac4dcb378a5448dd723f0784ae519383532f5e70ade24132c4c8693202" name = "gopkg.in/yaml.v2" packages = ["."] + pruneopts = "UT" revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183" version = "v2.2.1" [[projects]] branch = "release-1.8" + digest = "1:b7f1356b82d4992df7724d5d6e4ce7b7bbf878002b8a178560a425a0cd30b18c" name = "k8s.io/api" packages = [ "admissionregistration/v1alpha1", @@ -745,11 +906,13 @@ "scheduling/v1alpha1", "settings/v1alpha1", "storage/v1", - "storage/v1beta1" + "storage/v1beta1", ] + pruneopts = "UT" revision = "3c2a58f9923aeb5d27fa4d91249e45a1460ca3bd" [[projects]] + digest = "1:bfde7b4a64742525d92a21d3b7ed9695ad72e3922fc9263299b7f1b93f674de4" name = "k8s.io/apimachinery" packages = [ "pkg/api/equality", @@ -791,13 +954,15 @@ "pkg/util/yaml", "pkg/version", "pkg/watch", - "third_party/forked/golang/reflect" + "third_party/forked/golang/reflect", ] + pruneopts = "UT" revision = "9d38e20d609d27e00d4ec18f7b9db67105a2bde0" version = "kubernetes-1.8.0-rc.1" [[projects]] branch = "release-5.0" + digest = "1:591d0813c53cf297e808a2eabcd8bac67da8f92a4a2d1341812397f909618f65" name = "k8s.io/client-go" packages = [ "discovery", @@ -925,19 +1090,61 @@ "util/cert", "util/flowcontrol", "util/homedir", - "util/integer" + "util/integer", ] + pruneopts = "UT" revision = "45cf21002ef6b0320709b00606e38d89ed750fab" [[projects]] branch = "master" + digest = "1:f60e3ccfe35ad7632217492c6709871d6c84b2ba77219f054f8d0ef7d1b996e2" name = "k8s.io/kube-openapi" packages = ["pkg/common"] + pruneopts = "UT" revision = "f442ecb314a3679150c272e2b9713d8deed5955d" [solve-meta] analyzer-name = "dep" analyzer-version = 1 - inputs-digest = "084480bb06f84e536badc385a76b5e179e27caacc83b769fc984bad231429698" + input-imports = [ + "github.com/aws/aws-sdk-go/aws", + "github.com/aws/aws-sdk-go/aws/awserr", + "github.com/aws/aws-sdk-go/aws/ec2metadata", + "github.com/aws/aws-sdk-go/aws/session", + "github.com/aws/aws-sdk-go/service/ec2", + "github.com/containernetworking/cni/libcni", + "github.com/containernetworking/cni/plugins/ipam/host-local/backend/allocator", + "github.com/coreos/go-iptables/iptables", + "github.com/docker/docker/client", + "github.com/docker/libnetwork/ipvs", + "github.com/golang/glog", + "github.com/onsi/ginkgo", + "github.com/onsi/gomega", + "github.com/osrg/gobgp/api", + "github.com/osrg/gobgp/config", + "github.com/osrg/gobgp/gobgp", + "github.com/osrg/gobgp/packet/bgp", + "github.com/osrg/gobgp/server", + "github.com/osrg/gobgp/table", + "github.com/prometheus/client_golang/prometheus", + "github.com/prometheus/client_golang/prometheus/promhttp", + "github.com/spf13/pflag", + "github.com/vishvananda/netlink", + "github.com/vishvananda/netns", + "golang.org/x/net/context", + "k8s.io/api/core/v1", + "k8s.io/api/extensions/v1beta1", + "k8s.io/api/networking/v1", + "k8s.io/apimachinery/pkg/apis/meta/v1", + "k8s.io/apimachinery/pkg/labels", + "k8s.io/apimachinery/pkg/util/sets", + "k8s.io/client-go/informers", + "k8s.io/client-go/kubernetes", + "k8s.io/client-go/kubernetes/fake", + "k8s.io/client-go/listers/core/v1", + "k8s.io/client-go/rest", + "k8s.io/client-go/tools/cache", + "k8s.io/client-go/tools/clientcmd", + ] solver-name = "gps-cdcl" solver-version = 1 diff --git a/Gopkg.toml b/Gopkg.toml index 2fc70366..3fab6c52 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -57,7 +57,7 @@ required = ["github.com/osrg/gobgp/gobgp"] [[constraint]] name = "github.com/osrg/gobgp" - revision = "d31262de7d91c81ff979b39950d2d859666dfa3f" + revision = "v1.33" [[constraint]] name = "github.com/prometheus/client_golang" diff --git a/vendor/github.com/osrg/gobgp/api/attribute.go b/vendor/github.com/osrg/gobgp/api/attribute.go new file mode 100644 index 00000000..65ca6a4f --- /dev/null +++ b/vendor/github.com/osrg/gobgp/api/attribute.go @@ -0,0 +1,1334 @@ +// Copyright (C) 2018 Nippon Telegraph and Telephone Corporation. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +// implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package gobgpapi + +import ( + "fmt" + "net" + + "github.com/golang/protobuf/proto" + "github.com/golang/protobuf/ptypes" + "github.com/golang/protobuf/ptypes/any" + log "github.com/sirupsen/logrus" + + "github.com/osrg/gobgp/packet/bgp" +) + +func NewOriginAttributeFromNative(a *bgp.PathAttributeOrigin) *OriginAttribute { + return &OriginAttribute{ + Origin: uint32(a.Value), + } +} + +func (a *OriginAttribute) ToNative() (*bgp.PathAttributeOrigin, error) { + return bgp.NewPathAttributeOrigin(uint8(a.Origin)), nil +} + +func NewAsPathAttributeFromNative(a *bgp.PathAttributeAsPath) *AsPathAttribute { + segments := make([]*AsSegment, 0, len(a.Value)) + for _, param := range a.Value { + segments = append(segments, &AsSegment{ + Type: uint32(param.GetType()), + Numbers: param.GetAS(), + }) + } + return &AsPathAttribute{ + Segments: segments, + } +} + +func (a *AsPathAttribute) ToNative() (*bgp.PathAttributeAsPath, error) { + params := make([]bgp.AsPathParamInterface, 0, len(a.Segments)) + for _, segment := range a.Segments { + params = append(params, bgp.NewAs4PathParam(uint8(segment.Type), segment.Numbers)) + } + return bgp.NewPathAttributeAsPath(params), nil +} + +func NewNextHopAttributeFromNative(a *bgp.PathAttributeNextHop) *NextHopAttribute { + return &NextHopAttribute{ + NextHop: a.Value.String(), + } +} + +func (a *NextHopAttribute) ToNative() (*bgp.PathAttributeNextHop, error) { + nexthop := net.ParseIP(a.NextHop).To4() + if nexthop == nil { + return nil, fmt.Errorf("invalid nexthop address: %s", a.NextHop) + } + return bgp.NewPathAttributeNextHop(a.NextHop), nil +} + +func NewMultiExitDiscAttributeFromNative(a *bgp.PathAttributeMultiExitDisc) *MultiExitDiscAttribute { + return &MultiExitDiscAttribute{ + Med: a.Value, + } +} + +func (a *MultiExitDiscAttribute) ToNative() (*bgp.PathAttributeMultiExitDisc, error) { + return bgp.NewPathAttributeMultiExitDisc(a.Med), nil +} + +func NewLocalPrefAttributeFromNative(a *bgp.PathAttributeLocalPref) *LocalPrefAttribute { + return &LocalPrefAttribute{ + LocalPref: a.Value, + } +} + +func (a *LocalPrefAttribute) ToNative() (*bgp.PathAttributeLocalPref, error) { + return bgp.NewPathAttributeLocalPref(a.LocalPref), nil +} + +func NewAtomicAggregateAttributeFromNative(a *bgp.PathAttributeAtomicAggregate) *AtomicAggregateAttribute { + return &AtomicAggregateAttribute{} +} + +func (a *AtomicAggregateAttribute) ToNative() (*bgp.PathAttributeAtomicAggregate, error) { + return bgp.NewPathAttributeAtomicAggregate(), nil +} + +func NewAggregatorAttributeFromNative(a *bgp.PathAttributeAggregator) *AggregatorAttribute { + return &AggregatorAttribute{ + As: a.Value.AS, + Address: a.Value.Address.String(), + } +} + +func (a *AggregatorAttribute) ToNative() (*bgp.PathAttributeAggregator, error) { + if net.ParseIP(a.Address).To4() == nil { + return nil, fmt.Errorf("invalid aggregator address: %s", a.Address) + } + return bgp.NewPathAttributeAggregator(a.As, a.Address), nil +} + +func NewCommunitiesAttributeFromNative(a *bgp.PathAttributeCommunities) *CommunitiesAttribute { + return &CommunitiesAttribute{ + Communities: a.Value, + } +} + +func (a *CommunitiesAttribute) ToNative() (*bgp.PathAttributeCommunities, error) { + return bgp.NewPathAttributeCommunities(a.Communities), nil +} + +func NewOriginatorIdAttributeFromNative(a *bgp.PathAttributeOriginatorId) *OriginatorIdAttribute { + return &OriginatorIdAttribute{ + Id: a.Value.String(), + } +} + +func (a *OriginatorIdAttribute) ToNative() (*bgp.PathAttributeOriginatorId, error) { + if net.ParseIP(a.Id).To4() == nil { + return nil, fmt.Errorf("invalid originator id: %s", a.Id) + } + return bgp.NewPathAttributeOriginatorId(a.Id), nil +} + +func NewClusterListAttributeFromNative(a *bgp.PathAttributeClusterList) *ClusterListAttribute { + ids := make([]string, 0, len(a.Value)) + for _, id := range a.Value { + ids = append(ids, id.String()) + } + return &ClusterListAttribute{ + Ids: ids, + } +} + +func (a *ClusterListAttribute) ToNative() (*bgp.PathAttributeClusterList, error) { + for _, id := range a.Ids { + if net.ParseIP(id).To4() == nil { + return nil, fmt.Errorf("invalid cluster list: %s", a.Ids) + } + } + return bgp.NewPathAttributeClusterList(a.Ids), nil +} + +func MarshalRD(rd bgp.RouteDistinguisherInterface) *any.Any { + var r proto.Message + switch v := rd.(type) { + case *bgp.RouteDistinguisherTwoOctetAS: + r = &RouteDistinguisherTwoOctetAS{ + Admin: uint32(v.Admin), + Assigned: v.Assigned, + } + case *bgp.RouteDistinguisherIPAddressAS: + r = &RouteDistinguisherIPAddress{ + Admin: v.Admin.String(), + Assigned: uint32(v.Assigned), + } + case *bgp.RouteDistinguisherFourOctetAS: + r = &RouteDistinguisherFourOctetAS{ + Admin: v.Admin, + Assigned: uint32(v.Assigned), + } + default: + log.WithFields(log.Fields{ + "Topic": "protobuf", + "RD": rd, + }).Warn("invalid rd type to marshal") + return nil + } + a, _ := ptypes.MarshalAny(r) + return a +} + +func UnmarshalRD(a *any.Any) (bgp.RouteDistinguisherInterface, error) { + var value ptypes.DynamicAny + if err := ptypes.UnmarshalAny(a, &value); err != nil { + return nil, fmt.Errorf("failed to unmarshal route distinguisher: %s", err) + } + switch v := value.Message.(type) { + case *RouteDistinguisherTwoOctetAS: + return bgp.NewRouteDistinguisherTwoOctetAS(uint16(v.Admin), v.Assigned), nil + case *RouteDistinguisherIPAddress: + rd := bgp.NewRouteDistinguisherIPAddressAS(v.Admin, uint16(v.Assigned)) + if rd == nil { + return nil, fmt.Errorf("invalid address for route distinguisher: %s", v.Admin) + } + return rd, nil + case *RouteDistinguisherFourOctetAS: + return bgp.NewRouteDistinguisherFourOctetAS(v.Admin, uint16(v.Assigned)), nil + } + return nil, fmt.Errorf("invalid route distinguisher type: %s", a.TypeUrl) +} + +func NewEthernetSegmentIdentifierFromNative(a *bgp.EthernetSegmentIdentifier) *EthernetSegmentIdentifier { + return &EthernetSegmentIdentifier{ + Type: uint32(a.Type), + Value: a.Value, + } +} + +func (a *EthernetSegmentIdentifier) ToNative() (*bgp.EthernetSegmentIdentifier, error) { + return &bgp.EthernetSegmentIdentifier{ + Type: bgp.ESIType(a.Type), + Value: a.Value, + }, nil +} + +func MarshalFlowSpecRules(values []bgp.FlowSpecComponentInterface) []*any.Any { + rules := make([]*any.Any, 0, len(values)) + for _, value := range values { + var rule proto.Message + switch v := value.(type) { + case *bgp.FlowSpecDestinationPrefix: + rule = &FlowSpecIPPrefix{ + Type: uint32(bgp.FLOW_SPEC_TYPE_DST_PREFIX), + PrefixLen: uint32(v.Prefix.(*bgp.IPAddrPrefix).Length), + Prefix: v.Prefix.(*bgp.IPAddrPrefix).Prefix.String(), + } + case *bgp.FlowSpecSourcePrefix: + rule = &FlowSpecIPPrefix{ + Type: uint32(bgp.FLOW_SPEC_TYPE_SRC_PREFIX), + PrefixLen: uint32(v.Prefix.(*bgp.IPAddrPrefix).Length), + Prefix: v.Prefix.(*bgp.IPAddrPrefix).Prefix.String(), + } + case *bgp.FlowSpecDestinationPrefix6: + rule = &FlowSpecIPPrefix{ + Type: uint32(bgp.FLOW_SPEC_TYPE_DST_PREFIX), + PrefixLen: uint32(v.Prefix.(*bgp.IPv6AddrPrefix).Length), + Prefix: v.Prefix.(*bgp.IPv6AddrPrefix).Prefix.String(), + Offset: uint32(v.Offset), + } + case *bgp.FlowSpecSourcePrefix6: + rule = &FlowSpecIPPrefix{ + Type: uint32(bgp.FLOW_SPEC_TYPE_SRC_PREFIX), + PrefixLen: uint32(v.Prefix.(*bgp.IPv6AddrPrefix).Length), + Prefix: v.Prefix.(*bgp.IPv6AddrPrefix).Prefix.String(), + Offset: uint32(v.Offset), + } + case *bgp.FlowSpecSourceMac: + rule = &FlowSpecMAC{ + Type: uint32(bgp.FLOW_SPEC_TYPE_SRC_MAC), + Address: v.Mac.String(), + } + case *bgp.FlowSpecDestinationMac: + rule = &FlowSpecMAC{ + Type: uint32(bgp.FLOW_SPEC_TYPE_DST_MAC), + Address: v.Mac.String(), + } + case *bgp.FlowSpecComponent: + items := make([]*FlowSpecComponentItem, 0, len(v.Items)) + for _, i := range v.Items { + items = append(items, &FlowSpecComponentItem{ + Op: uint32(i.Op), + Value: i.Value, + }) + } + rule = &FlowSpecComponent{ + Type: uint32(v.Type()), + Items: items, + } + } + a, _ := ptypes.MarshalAny(rule) + rules = append(rules, a) + } + return rules +} + +func UnmarshalFlowSpecRules(values []*any.Any) ([]bgp.FlowSpecComponentInterface, error) { + rules := make([]bgp.FlowSpecComponentInterface, 0, len(values)) + for _, an := range values { + var rule bgp.FlowSpecComponentInterface + var value ptypes.DynamicAny + if err := ptypes.UnmarshalAny(an, &value); err != nil { + return nil, fmt.Errorf("failed to unmarshal flow spec component: %s", err) + } + switch v := value.Message.(type) { + case *FlowSpecIPPrefix: + typ := bgp.BGPFlowSpecType(v.Type) + isIPv4 := net.ParseIP(v.Prefix).To4() != nil + switch { + case typ == bgp.FLOW_SPEC_TYPE_DST_PREFIX && isIPv4: + rule = bgp.NewFlowSpecDestinationPrefix(bgp.NewIPAddrPrefix(uint8(v.PrefixLen), v.Prefix)) + case typ == bgp.FLOW_SPEC_TYPE_SRC_PREFIX && isIPv4: + rule = bgp.NewFlowSpecSourcePrefix(bgp.NewIPAddrPrefix(uint8(v.PrefixLen), v.Prefix)) + case typ == bgp.FLOW_SPEC_TYPE_DST_PREFIX && !isIPv4: + rule = bgp.NewFlowSpecDestinationPrefix6(bgp.NewIPv6AddrPrefix(uint8(v.PrefixLen), v.Prefix), uint8(v.Offset)) + case typ == bgp.FLOW_SPEC_TYPE_SRC_PREFIX && !isIPv4: + rule = bgp.NewFlowSpecSourcePrefix6(bgp.NewIPv6AddrPrefix(uint8(v.PrefixLen), v.Prefix), uint8(v.Offset)) + } + case *FlowSpecMAC: + typ := bgp.BGPFlowSpecType(v.Type) + mac, err := net.ParseMAC(v.Address) + if err != nil { + return nil, fmt.Errorf("invalid mac address for %s flow spec component: %s", typ.String(), v.Address) + } + switch typ { + case bgp.FLOW_SPEC_TYPE_SRC_MAC: + rule = bgp.NewFlowSpecSourceMac(mac) + case bgp.FLOW_SPEC_TYPE_DST_MAC: + rule = bgp.NewFlowSpecDestinationMac(mac) + } + case *FlowSpecComponent: + items := make([]*bgp.FlowSpecComponentItem, 0, len(v.Items)) + for _, item := range v.Items { + items = append(items, bgp.NewFlowSpecComponentItem(uint8(item.Op), item.Value)) + } + rule = bgp.NewFlowSpecComponent(bgp.BGPFlowSpecType(v.Type), items) + } + if rule == nil { + return nil, fmt.Errorf("invalid flow spec component: %v", value.Message) + } + rules = append(rules, rule) + } + return rules, nil +} + +func MarshalNLRI(value bgp.AddrPrefixInterface) *any.Any { + var nlri proto.Message + + switch v := value.(type) { + case *bgp.IPAddrPrefix: + nlri = &IPAddressPrefix{ + PrefixLen: uint32(v.Length), + Prefix: v.Prefix.String(), + } + case *bgp.IPv6AddrPrefix: + nlri = &IPAddressPrefix{ + PrefixLen: uint32(v.Length), + Prefix: v.Prefix.String(), + } + case *bgp.LabeledIPAddrPrefix: + nlri = &LabeledIPAddressPrefix{ + Labels: v.Labels.Labels, + PrefixLen: uint32(v.IPPrefixLen()), + Prefix: v.Prefix.String(), + } + case *bgp.LabeledIPv6AddrPrefix: + nlri = &LabeledIPAddressPrefix{ + Labels: v.Labels.Labels, + PrefixLen: uint32(v.IPPrefixLen()), + Prefix: v.Prefix.String(), + } + case *bgp.EncapNLRI: + nlri = &EncapsulationNLRI{ + Address: v.String(), + } + case *bgp.Encapv6NLRI: + nlri = &EncapsulationNLRI{ + Address: v.String(), + } + case *bgp.EVPNNLRI: + switch r := v.RouteTypeData.(type) { + case *bgp.EVPNEthernetAutoDiscoveryRoute: + nlri = &EVPNEthernetAutoDiscoveryRoute{ + Rd: MarshalRD(r.RD), + Esi: NewEthernetSegmentIdentifierFromNative(&r.ESI), + EthernetTag: r.ETag, + Label: r.Label, + } + case *bgp.EVPNMacIPAdvertisementRoute: + nlri = &EVPNMACIPAdvertisementRoute{ + Rd: MarshalRD(r.RD), + Esi: NewEthernetSegmentIdentifierFromNative(&r.ESI), + EthernetTag: r.ETag, + MacAddress: r.MacAddress.String(), + IpAddress: r.IPAddress.String(), + Labels: r.Labels, + } + case *bgp.EVPNMulticastEthernetTagRoute: + nlri = &EVPNInclusiveMulticastEthernetTagRoute{ + Rd: MarshalRD(r.RD), + EthernetTag: r.ETag, + IpAddress: r.IPAddress.String(), + } + case *bgp.EVPNEthernetSegmentRoute: + nlri = &EVPNEthernetSegmentRoute{ + Rd: MarshalRD(r.RD), + Esi: NewEthernetSegmentIdentifierFromNative(&r.ESI), + IpAddress: r.IPAddress.String(), + } + case *bgp.EVPNIPPrefixRoute: + nlri = &EVPNIPPrefixRoute{ + Rd: MarshalRD(r.RD), + Esi: NewEthernetSegmentIdentifierFromNative(&r.ESI), + EthernetTag: r.ETag, + IpPrefix: r.IPPrefix.String(), + IpPrefixLen: uint32(r.IPPrefixLength), + Label: r.Label, + } + } + case *bgp.LabeledVPNIPAddrPrefix: + nlri = &LabeledVPNIPAddressPrefix{ + Labels: v.Labels.Labels, + Rd: MarshalRD(v.RD), + PrefixLen: uint32(v.IPPrefixLen()), + Prefix: v.Prefix.String(), + } + case *bgp.LabeledVPNIPv6AddrPrefix: + nlri = &LabeledVPNIPAddressPrefix{ + Labels: v.Labels.Labels, + Rd: MarshalRD(v.RD), + PrefixLen: uint32(v.IPPrefixLen()), + Prefix: v.Prefix.String(), + } + case *bgp.RouteTargetMembershipNLRI: + nlri = &RouteTargetMembershipNLRI{ + As: v.AS, + Rt: MarshalRT(v.RouteTarget), + } + case *bgp.FlowSpecIPv4Unicast: + nlri = &FlowSpecNLRI{ + Rules: MarshalFlowSpecRules(v.Value), + } + case *bgp.FlowSpecIPv6Unicast: + nlri = &FlowSpecNLRI{ + Rules: MarshalFlowSpecRules(v.Value), + } + case *bgp.FlowSpecIPv4VPN: + nlri = &VPNFlowSpecNLRI{ + Rd: MarshalRD(v.RD()), + Rules: MarshalFlowSpecRules(v.Value), + } + case *bgp.FlowSpecIPv6VPN: + nlri = &VPNFlowSpecNLRI{ + Rd: MarshalRD(v.RD()), + Rules: MarshalFlowSpecRules(v.Value), + } + case *bgp.FlowSpecL2VPN: + nlri = &VPNFlowSpecNLRI{ + Rd: MarshalRD(v.RD()), + Rules: MarshalFlowSpecRules(v.Value), + } + } + + an, _ := ptypes.MarshalAny(nlri) + return an +} + +func MarshalNLRIs(values []bgp.AddrPrefixInterface) []*any.Any { + nlris := make([]*any.Any, 0, len(values)) + for _, value := range values { + nlris = append(nlris, MarshalNLRI(value)) + } + return nlris +} + +func UnmarshalNLRI(rf bgp.RouteFamily, an *any.Any) (bgp.AddrPrefixInterface, error) { + var nlri bgp.AddrPrefixInterface + + var value ptypes.DynamicAny + if err := ptypes.UnmarshalAny(an, &value); err != nil { + return nil, fmt.Errorf("failed to unmarshal nlri: %s", err) + } + + switch v := value.Message.(type) { + case *IPAddressPrefix: + switch rf { + case bgp.RF_IPv4_UC: + nlri = bgp.NewIPAddrPrefix(uint8(v.PrefixLen), v.Prefix) + case bgp.RF_IPv6_UC: + nlri = bgp.NewIPv6AddrPrefix(uint8(v.PrefixLen), v.Prefix) + } + case *LabeledIPAddressPrefix: + switch rf { + case bgp.RF_IPv4_MPLS: + nlri = bgp.NewLabeledIPAddrPrefix(uint8(v.PrefixLen), v.Prefix, *bgp.NewMPLSLabelStack(v.Labels...)) + case bgp.RF_IPv6_MPLS: + nlri = bgp.NewLabeledIPv6AddrPrefix(uint8(v.PrefixLen), v.Prefix, *bgp.NewMPLSLabelStack(v.Labels...)) + } + case *EncapsulationNLRI: + switch rf { + case bgp.RF_IPv4_ENCAP: + nlri = bgp.NewEncapNLRI(v.Address) + case bgp.RF_IPv6_ENCAP: + nlri = bgp.NewEncapv6NLRI(v.Address) + } + case *EVPNEthernetAutoDiscoveryRoute: + if rf == bgp.RF_EVPN { + rd, err := UnmarshalRD(v.Rd) + if err != nil { + return nil, err + } + esi, err := v.Esi.ToNative() + if err != nil { + return nil, err + } + nlri = bgp.NewEVPNEthernetAutoDiscoveryRoute(rd, *esi, v.EthernetTag, v.Label) + } + case *EVPNMACIPAdvertisementRoute: + if rf == bgp.RF_EVPN { + rd, err := UnmarshalRD(v.Rd) + if err != nil { + return nil, err + } + esi, err := v.Esi.ToNative() + if err != nil { + return nil, err + } + nlri = bgp.NewEVPNMacIPAdvertisementRoute(rd, *esi, v.EthernetTag, v.MacAddress, v.IpAddress, v.Labels) + } + case *EVPNInclusiveMulticastEthernetTagRoute: + if rf == bgp.RF_EVPN { + rd, err := UnmarshalRD(v.Rd) + if err != nil { + return nil, err + } + nlri = bgp.NewEVPNMulticastEthernetTagRoute(rd, v.EthernetTag, v.IpAddress) + } + case *EVPNEthernetSegmentRoute: + if rf == bgp.RF_EVPN { + rd, err := UnmarshalRD(v.Rd) + if err != nil { + return nil, err + } + esi, err := v.Esi.ToNative() + if err != nil { + return nil, err + } + nlri = bgp.NewEVPNEthernetSegmentRoute(rd, *esi, v.IpAddress) + } + case *EVPNIPPrefixRoute: + if rf == bgp.RF_EVPN { + rd, err := UnmarshalRD(v.Rd) + if err != nil { + return nil, err + } + esi, err := v.Esi.ToNative() + if err != nil { + return nil, err + } + nlri = bgp.NewEVPNIPPrefixRoute(rd, *esi, v.EthernetTag, uint8(v.IpPrefixLen), v.IpPrefix, v.GwAddress, v.Label) + } + case *LabeledVPNIPAddressPrefix: + rd, err := UnmarshalRD(v.Rd) + if err != nil { + return nil, err + } + switch rf { + case bgp.RF_IPv4_VPN: + nlri = bgp.NewLabeledVPNIPAddrPrefix(uint8(v.PrefixLen), v.Prefix, *bgp.NewMPLSLabelStack(v.Labels...), rd) + case bgp.RF_IPv6_VPN: + nlri = bgp.NewLabeledVPNIPv6AddrPrefix(uint8(v.PrefixLen), v.Prefix, *bgp.NewMPLSLabelStack(v.Labels...), rd) + } + case *RouteTargetMembershipNLRI: + rt, err := UnmarshalRT(v.Rt) + if err != nil { + return nil, err + } + nlri = bgp.NewRouteTargetMembershipNLRI(v.As, rt) + case *FlowSpecNLRI: + rules, err := UnmarshalFlowSpecRules(v.Rules) + if err != nil { + return nil, err + } + switch rf { + case bgp.RF_FS_IPv4_UC: + nlri = bgp.NewFlowSpecIPv4Unicast(rules) + case bgp.RF_FS_IPv6_UC: + nlri = bgp.NewFlowSpecIPv6Unicast(rules) + } + case *VPNFlowSpecNLRI: + rd, err := UnmarshalRD(v.Rd) + if err != nil { + return nil, err + } + rules, err := UnmarshalFlowSpecRules(v.Rules) + if err != nil { + return nil, err + } + switch rf { + case bgp.RF_FS_IPv4_VPN: + nlri = bgp.NewFlowSpecIPv4VPN(rd, rules) + case bgp.RF_FS_IPv6_VPN: + nlri = bgp.NewFlowSpecIPv6VPN(rd, rules) + case bgp.RF_FS_L2_VPN: + nlri = bgp.NewFlowSpecL2VPN(rd, rules) + } + } + + if nlri == nil { + return nil, fmt.Errorf("invalid nlri for %s family: %s", rf.String(), value.Message) + } + + return nlri, nil +} + +func UnmarshalNLRIs(rf bgp.RouteFamily, values []*any.Any) ([]bgp.AddrPrefixInterface, error) { + nlris := make([]bgp.AddrPrefixInterface, 0, len(values)) + for _, an := range values { + nlri, err := UnmarshalNLRI(rf, an) + if err != nil { + return nil, err + } + nlris = append(nlris, nlri) + } + return nlris, nil +} + +func NewMpReachNLRIAttributeFromNative(a *bgp.PathAttributeMpReachNLRI) *MpReachNLRIAttribute { + var nexthops []string + if a.SAFI == bgp.SAFI_FLOW_SPEC_UNICAST || a.SAFI == bgp.SAFI_FLOW_SPEC_VPN { + nexthops = nil + } else { + nexthops = []string{a.Nexthop.String()} + if a.LinkLocalNexthop != nil { + nexthops = append(nexthops, a.LinkLocalNexthop.String()) + } + } + return &MpReachNLRIAttribute{ + Family: uint32(bgp.AfiSafiToRouteFamily(a.AFI, a.SAFI)), + NextHops: nexthops, + Nlris: MarshalNLRIs(a.Value), + } +} + +func (a *MpReachNLRIAttribute) ToNative() (*bgp.PathAttributeMpReachNLRI, error) { + rf := bgp.RouteFamily(a.Family) + nlris, err := UnmarshalNLRIs(rf, a.Nlris) + if err != nil { + return nil, err + } + afi, safi := bgp.RouteFamilyToAfiSafi(rf) + nexthop := "0.0.0.0" + var linkLocalNexthop net.IP + if afi == bgp.AFI_IP6 { + nexthop = "::" + if len(a.NextHops) > 1 { + linkLocalNexthop = net.ParseIP(a.NextHops[1]).To16() + if linkLocalNexthop == nil { + return nil, fmt.Errorf("invalid nexthop: %s", a.NextHops[1]) + } + } + } + if safi == bgp.SAFI_FLOW_SPEC_UNICAST || safi == bgp.SAFI_FLOW_SPEC_VPN { + nexthop = "" + } else if len(a.NextHops) > 0 { + nexthop = a.NextHops[0] + if net.ParseIP(nexthop) == nil { + return nil, fmt.Errorf("invalid nexthop: %s", nexthop) + } + } + attr := bgp.NewPathAttributeMpReachNLRI(nexthop, nlris) + attr.LinkLocalNexthop = linkLocalNexthop + return attr, nil +} + +func NewMpUnreachNLRIAttributeFromNative(a *bgp.PathAttributeMpUnreachNLRI) *MpUnreachNLRIAttribute { + return &MpUnreachNLRIAttribute{ + Family: uint32(bgp.AfiSafiToRouteFamily(a.AFI, a.SAFI)), + Nlris: MarshalNLRIs(a.Value), + } +} + +func (a *MpUnreachNLRIAttribute) ToNative() (*bgp.PathAttributeMpUnreachNLRI, error) { + rf := bgp.RouteFamily(a.Family) + nlris, err := UnmarshalNLRIs(rf, a.Nlris) + if err != nil { + return nil, err + } + return bgp.NewPathAttributeMpUnreachNLRI(nlris), nil +} + +func MarshalRT(rt bgp.ExtendedCommunityInterface) *any.Any { + var r proto.Message + switch v := rt.(type) { + case *bgp.TwoOctetAsSpecificExtended: + r = &TwoOctetAsSpecificExtended{ + IsTransitive: true, + SubType: uint32(bgp.EC_SUBTYPE_ROUTE_TARGET), + As: uint32(v.AS), + LocalAdmin: uint32(v.LocalAdmin), + } + case *bgp.IPv4AddressSpecificExtended: + r = &IPv4AddressSpecificExtended{ + IsTransitive: true, + SubType: uint32(bgp.EC_SUBTYPE_ROUTE_TARGET), + Address: v.IPv4.String(), + LocalAdmin: uint32(v.LocalAdmin), + } + case *bgp.FourOctetAsSpecificExtended: + r = &FourOctetAsSpecificExtended{ + IsTransitive: true, + SubType: uint32(bgp.EC_SUBTYPE_ROUTE_TARGET), + As: uint32(v.AS), + LocalAdmin: uint32(v.LocalAdmin), + } + default: + log.WithFields(log.Fields{ + "Topic": "protobuf", + "RT": rt, + }).Warn("invalid rt type to marshal") + return nil + } + a, _ := ptypes.MarshalAny(r) + return a +} + +func MarshalRTs(values []bgp.ExtendedCommunityInterface) []*any.Any { + rts := make([]*any.Any, 0, len(values)) + for _, rt := range values { + rts = append(rts, MarshalRT(rt)) + } + return rts +} + +func UnmarshalRT(a *any.Any) (bgp.ExtendedCommunityInterface, error) { + var value ptypes.DynamicAny + if err := ptypes.UnmarshalAny(a, &value); err != nil { + return nil, fmt.Errorf("failed to unmarshal route target: %s", err) + } + switch v := value.Message.(type) { + case *TwoOctetAsSpecificExtended: + return bgp.NewTwoOctetAsSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), uint16(v.As), v.LocalAdmin, v.IsTransitive), nil + case *IPv4AddressSpecificExtended: + rt := bgp.NewIPv4AddressSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), v.Address, uint16(v.LocalAdmin), v.IsTransitive) + if rt == nil { + return nil, fmt.Errorf("invalid address for ipv4 address specific route target: %s", v.Address) + } + return rt, nil + case *FourOctetAsSpecificExtended: + return bgp.NewFourOctetAsSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), v.As, uint16(v.LocalAdmin), v.IsTransitive), nil + } + return nil, fmt.Errorf("invalid route target type: %s", a.TypeUrl) +} + +func UnmarshalRTs(values []*any.Any) ([]bgp.ExtendedCommunityInterface, error) { + rts := make([]bgp.ExtendedCommunityInterface, 0, len(values)) + for _, an := range values { + rt, err := UnmarshalRT(an) + if err != nil { + return nil, err + } + rts = append(rts, rt) + } + return rts, nil +} + +func NewExtendedCommunitiesAttributeFromNative(a *bgp.PathAttributeExtendedCommunities) *ExtendedCommunitiesAttribute { + communities := make([]*any.Any, 0, len(a.Value)) + for _, value := range a.Value { + var community proto.Message + switch v := value.(type) { + case *bgp.TwoOctetAsSpecificExtended: + community = &TwoOctetAsSpecificExtended{ + IsTransitive: v.IsTransitive, + SubType: uint32(v.SubType), + As: uint32(v.AS), + LocalAdmin: uint32(v.LocalAdmin), + } + case *bgp.IPv4AddressSpecificExtended: + community = &IPv4AddressSpecificExtended{ + IsTransitive: v.IsTransitive, + SubType: uint32(v.SubType), + Address: v.IPv4.String(), + LocalAdmin: uint32(v.LocalAdmin), + } + case *bgp.FourOctetAsSpecificExtended: + community = &FourOctetAsSpecificExtended{ + IsTransitive: v.IsTransitive, + SubType: uint32(v.SubType), + As: uint32(v.AS), + LocalAdmin: uint32(v.LocalAdmin), + } + case *bgp.ValidationExtended: + community = &ValidationExtended{ + State: uint32(v.State), + } + case *bgp.ColorExtended: + community = &ColorExtended{ + Color: v.Color, + } + case *bgp.EncapExtended: + community = &EncapExtended{ + TunnelType: uint32(v.TunnelType), + } + case *bgp.DefaultGatewayExtended: + community = &DefaultGatewayExtended{} + case *bgp.OpaqueExtended: + community = &OpaqueExtended{ + IsTransitive: v.IsTransitive, + Value: v.Value, + } + case *bgp.ESILabelExtended: + community = &ESILabelExtended{ + IsSingleActive: v.IsSingleActive, + Label: v.Label, + } + case *bgp.ESImportRouteTarget: + community = &ESImportRouteTarget{ + EsImport: v.ESImport.String(), + } + case *bgp.MacMobilityExtended: + community = &MacMobilityExtended{ + IsSticky: v.IsSticky, + SequenceNum: v.Sequence, + } + case *bgp.RouterMacExtended: + community = &RouterMacExtended{ + Mac: v.Mac.String(), + } + case *bgp.TrafficRateExtended: + community = &TrafficRateExtended{ + As: uint32(v.AS), + Rate: v.Rate, + } + case *bgp.TrafficActionExtended: + community = &TrafficActionExtended{ + Terminal: v.Terminal, + Sample: v.Sample, + } + case *bgp.RedirectTwoOctetAsSpecificExtended: + community = &RedirectTwoOctetAsSpecificExtended{ + As: uint32(v.AS), + LocalAdmin: v.LocalAdmin, + } + case *bgp.RedirectIPv4AddressSpecificExtended: + community = &RedirectIPv4AddressSpecificExtended{ + Address: v.IPv4.String(), + LocalAdmin: uint32(v.LocalAdmin), + } + case *bgp.RedirectFourOctetAsSpecificExtended: + community = &RedirectFourOctetAsSpecificExtended{ + As: v.AS, + LocalAdmin: uint32(v.LocalAdmin), + } + case *bgp.TrafficRemarkExtended: + community = &TrafficRemarkExtended{ + Dscp: uint32(v.DSCP), + } + case *bgp.UnknownExtended: + community = &UnknownExtended{ + Type: uint32(v.Type), + Value: v.Value, + } + default: + log.WithFields(log.Fields{ + "Topic": "protobuf", + "Community": value, + }).Warn("unsupported extended community") + return nil + } + an, _ := ptypes.MarshalAny(community) + communities = append(communities, an) + } + return &ExtendedCommunitiesAttribute{ + Communities: communities, + } +} + +func (a *ExtendedCommunitiesAttribute) ToNative() (*bgp.PathAttributeExtendedCommunities, error) { + communities := make([]bgp.ExtendedCommunityInterface, 0, len(a.Communities)) + for _, an := range a.Communities { + var community bgp.ExtendedCommunityInterface + var value ptypes.DynamicAny + if err := ptypes.UnmarshalAny(an, &value); err != nil { + return nil, fmt.Errorf("failed to unmarshal extended community: %s", err) + } + switch v := value.Message.(type) { + case *TwoOctetAsSpecificExtended: + community = bgp.NewTwoOctetAsSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), uint16(v.As), v.LocalAdmin, v.IsTransitive) + case *IPv4AddressSpecificExtended: + community = bgp.NewIPv4AddressSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), v.Address, uint16(v.LocalAdmin), v.IsTransitive) + case *FourOctetAsSpecificExtended: + community = bgp.NewFourOctetAsSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), v.As, uint16(v.LocalAdmin), v.IsTransitive) + case *ValidationExtended: + community = bgp.NewValidationExtended(bgp.ValidationState(v.State)) + case *ColorExtended: + community = bgp.NewColorExtended(v.Color) + case *EncapExtended: + community = bgp.NewEncapExtended(bgp.TunnelType(v.TunnelType)) + case *DefaultGatewayExtended: + community = bgp.NewDefaultGatewayExtended() + case *OpaqueExtended: + community = bgp.NewOpaqueExtended(v.IsTransitive, v.Value) + case *ESILabelExtended: + community = bgp.NewESILabelExtended(v.Label, v.IsSingleActive) + case *ESImportRouteTarget: + community = bgp.NewESImportRouteTarget(v.EsImport) + case *MacMobilityExtended: + community = bgp.NewMacMobilityExtended(v.SequenceNum, v.IsSticky) + case *RouterMacExtended: + community = bgp.NewRoutersMacExtended(v.Mac) + case *TrafficRateExtended: + community = bgp.NewTrafficRateExtended(uint16(v.As), v.Rate) + case *TrafficActionExtended: + community = bgp.NewTrafficActionExtended(v.Terminal, v.Sample) + case *RedirectTwoOctetAsSpecificExtended: + community = bgp.NewRedirectTwoOctetAsSpecificExtended(uint16(v.As), v.LocalAdmin) + case *RedirectIPv4AddressSpecificExtended: + community = bgp.NewRedirectIPv4AddressSpecificExtended(v.Address, uint16(v.LocalAdmin)) + case *RedirectFourOctetAsSpecificExtended: + community = bgp.NewRedirectFourOctetAsSpecificExtended(v.As, uint16(v.LocalAdmin)) + case *TrafficRemarkExtended: + community = bgp.NewTrafficRemarkExtended(uint8(v.Dscp)) + case *UnknownExtended: + community = bgp.NewUnknownExtended(bgp.ExtendedCommunityAttrType(v.Type), v.Value) + } + if community == nil { + return nil, fmt.Errorf("invalid extended community: %v", value.Message) + } + communities = append(communities, community) + } + return bgp.NewPathAttributeExtendedCommunities(communities), nil +} + +func NewAs4PathAttributeFromNative(a *bgp.PathAttributeAs4Path) *As4PathAttribute { + segments := make([]*AsSegment, 0, len(a.Value)) + for _, param := range a.Value { + segments = append(segments, &AsSegment{ + Type: uint32(param.Type), + Numbers: param.AS, + }) + } + return &As4PathAttribute{ + Segments: segments, + } +} + +func (a *As4PathAttribute) ToNative() (*bgp.PathAttributeAs4Path, error) { + params := make([]*bgp.As4PathParam, 0, len(a.Segments)) + for _, segment := range a.Segments { + params = append(params, bgp.NewAs4PathParam(uint8(segment.Type), segment.Numbers)) + } + return bgp.NewPathAttributeAs4Path(params), nil +} + +func NewAs4AggregatorAttributeFromNative(a *bgp.PathAttributeAs4Aggregator) *As4AggregatorAttribute { + return &As4AggregatorAttribute{ + As: a.Value.AS, + Address: a.Value.Address.String(), + } +} + +func (a *As4AggregatorAttribute) ToNative() (*bgp.PathAttributeAs4Aggregator, error) { + if net.ParseIP(a.Address).To4() == nil { + return nil, fmt.Errorf("invalid as4 aggregator address: %s", a.Address) + } + return bgp.NewPathAttributeAs4Aggregator(a.As, a.Address), nil +} + +func NewPmsiTunnelAttributeFromNative(a *bgp.PathAttributePmsiTunnel) *PmsiTunnelAttribute { + var flags uint32 + if a.IsLeafInfoRequired { + flags |= 0x01 + } + id, _ := a.TunnelID.Serialize() + return &PmsiTunnelAttribute{ + Flags: flags, + Type: uint32(a.TunnelType), + Label: a.Label, + Id: id, + } +} + +func (a *PmsiTunnelAttribute) ToNative() (*bgp.PathAttributePmsiTunnel, error) { + typ := bgp.PmsiTunnelType(a.Type) + var isLeafInfoRequired bool + if a.Flags&0x01 > 0 { + isLeafInfoRequired = true + } + var id bgp.PmsiTunnelIDInterface + switch typ { + case bgp.PMSI_TUNNEL_TYPE_INGRESS_REPL: + ip := net.IP(a.Id) + if ip.To4() == nil && ip.To16() == nil { + return nil, fmt.Errorf("invalid pmsi tunnel identifier: %s", a.Id) + } + id = bgp.NewIngressReplTunnelID(ip.String()) + default: + id = bgp.NewDefaultPmsiTunnelID(a.Id) + } + return bgp.NewPathAttributePmsiTunnel(typ, isLeafInfoRequired, a.Label, id), nil +} + +func NewTunnelEncapAttributeFromNative(a *bgp.PathAttributeTunnelEncap) *TunnelEncapAttribute { + tlvs := make([]*TunnelEncapTLV, 0, len(a.Value)) + for _, v := range a.Value { + subTlvs := make([]*any.Any, 0, len(v.Value)) + for _, s := range v.Value { + var subTlv proto.Message + switch sv := s.(type) { + case *bgp.TunnelEncapSubTLVEncapsulation: + subTlv = &TunnelEncapSubTLVEncapsulation{ + Key: sv.Key, + Cookie: sv.Cookie, + } + case *bgp.TunnelEncapSubTLVProtocol: + subTlv = &TunnelEncapSubTLVProtocol{ + Protocol: uint32(sv.Protocol), + } + case *bgp.TunnelEncapSubTLVColor: + subTlv = &TunnelEncapSubTLVColor{ + Color: sv.Color, + } + case *bgp.TunnelEncapSubTLVUnknown: + subTlv = &TunnelEncapSubTLVUnknown{ + Type: uint32(sv.Type), + Value: sv.Value, + } + } + an, _ := ptypes.MarshalAny(subTlv) + subTlvs = append(subTlvs, an) + } + tlvs = append(tlvs, &TunnelEncapTLV{ + Type: uint32(v.Type), + Tlvs: subTlvs, + }) + } + return &TunnelEncapAttribute{ + Tlvs: tlvs, + } +} + +func (a *TunnelEncapAttribute) ToNative() (*bgp.PathAttributeTunnelEncap, error) { + tlvs := make([]*bgp.TunnelEncapTLV, 0, len(a.Tlvs)) + for _, tlv := range a.Tlvs { + subTlvs := make([]bgp.TunnelEncapSubTLVInterface, 0, len(tlv.Tlvs)) + for _, an := range tlv.Tlvs { + var subTlv bgp.TunnelEncapSubTLVInterface + var subValue ptypes.DynamicAny + if err := ptypes.UnmarshalAny(an, &subValue); err != nil { + return nil, fmt.Errorf("failed to unmarshal tunnel encapsulation attribute sub tlv: %s", err) + } + switch sv := subValue.Message.(type) { + case *TunnelEncapSubTLVEncapsulation: + subTlv = bgp.NewTunnelEncapSubTLVEncapsulation(sv.Key, sv.Cookie) + case *TunnelEncapSubTLVProtocol: + subTlv = bgp.NewTunnelEncapSubTLVProtocol(uint16(sv.Protocol)) + case *TunnelEncapSubTLVColor: + subTlv = bgp.NewTunnelEncapSubTLVColor(sv.Color) + case *TunnelEncapSubTLVUnknown: + subTlv = bgp.NewTunnelEncapSubTLVUnknown(bgp.EncapSubTLVType(sv.Type), sv.Value) + default: + return nil, fmt.Errorf("invalid tunnel encapsulation attribute sub tlv: %v", subValue.Message) + } + subTlvs = append(subTlvs, subTlv) + } + tlvs = append(tlvs, bgp.NewTunnelEncapTLV(bgp.TunnelType(tlv.Type), subTlvs)) + } + return bgp.NewPathAttributeTunnelEncap(tlvs), nil +} + +func NewIP6ExtendedCommunitiesAttributeFromNative(a *bgp.PathAttributeIP6ExtendedCommunities) *IP6ExtendedCommunitiesAttribute { + communities := make([]*any.Any, 0, len(a.Value)) + for _, value := range a.Value { + var community proto.Message + switch v := value.(type) { + case *bgp.IPv6AddressSpecificExtended: + community = &IPv6AddressSpecificExtended{ + IsTransitive: v.IsTransitive, + SubType: uint32(v.SubType), + Address: v.IPv6.String(), + LocalAdmin: uint32(v.LocalAdmin), + } + case *bgp.RedirectIPv6AddressSpecificExtended: + community = &RedirectIPv6AddressSpecificExtended{ + Address: v.IPv6.String(), + LocalAdmin: uint32(v.LocalAdmin), + } + default: + log.WithFields(log.Fields{ + "Topic": "protobuf", + "Attribute": value, + }).Warn("invalid ipv6 extended community") + return nil + } + an, _ := ptypes.MarshalAny(community) + communities = append(communities, an) + } + return &IP6ExtendedCommunitiesAttribute{ + Communities: communities, + } +} + +func (a *IP6ExtendedCommunitiesAttribute) ToNative() (*bgp.PathAttributeIP6ExtendedCommunities, error) { + communities := make([]bgp.ExtendedCommunityInterface, 0, len(a.Communities)) + for _, an := range a.Communities { + var community bgp.ExtendedCommunityInterface + var value ptypes.DynamicAny + if err := ptypes.UnmarshalAny(an, &value); err != nil { + return nil, fmt.Errorf("failed to unmarshal ipv6 extended community: %s", err) + } + switch v := value.Message.(type) { + case *IPv6AddressSpecificExtended: + community = bgp.NewIPv6AddressSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), v.Address, uint16(v.LocalAdmin), v.IsTransitive) + case *RedirectIPv6AddressSpecificExtended: + community = bgp.NewRedirectIPv6AddressSpecificExtended(v.Address, uint16(v.LocalAdmin)) + } + if community == nil { + return nil, fmt.Errorf("invalid ipv6 extended community: %v", value.Message) + } + communities = append(communities, community) + } + return bgp.NewPathAttributeIP6ExtendedCommunities(communities), nil +} + +func NewAigpAttributeFromNative(a *bgp.PathAttributeAigp) *AigpAttribute { + tlvs := make([]*any.Any, 0, len(a.Values)) + for _, value := range a.Values { + var tlv proto.Message + switch v := value.(type) { + case *bgp.AigpTLVIgpMetric: + tlv = &AigpTLVIGPMetric{ + Metric: v.Metric, + } + case *bgp.AigpTLVDefault: + tlv = &AigpTLVUnknown{ + Type: uint32(v.Type()), + Value: v.Value, + } + } + an, _ := ptypes.MarshalAny(tlv) + tlvs = append(tlvs, an) + } + return &AigpAttribute{ + Tlvs: tlvs, + } +} + +func (a *AigpAttribute) ToNative() (*bgp.PathAttributeAigp, error) { + tlvs := make([]bgp.AigpTLVInterface, 0, len(a.Tlvs)) + for _, an := range a.Tlvs { + var tlv bgp.AigpTLVInterface + var value ptypes.DynamicAny + if err := ptypes.UnmarshalAny(an, &value); err != nil { + return nil, fmt.Errorf("failed to unmarshal aigp attribute tlv: %s", err) + } + switch v := value.Message.(type) { + case *AigpTLVIGPMetric: + tlv = bgp.NewAigpTLVIgpMetric(v.Metric) + case *AigpTLVUnknown: + tlv = bgp.NewAigpTLVDefault(bgp.AigpTLVType(v.Type), v.Value) + } + if tlv == nil { + return nil, fmt.Errorf("invalid aigp attribute tlv: %v", value.Message) + } + tlvs = append(tlvs, tlv) + } + return bgp.NewPathAttributeAigp(tlvs), nil +} + +func NewLargeCommunitiesAttributeFromNative(a *bgp.PathAttributeLargeCommunities) *LargeCommunitiesAttribute { + communities := make([]*LargeCommunity, 0, len(a.Values)) + for _, v := range a.Values { + communities = append(communities, &LargeCommunity{ + GlobalAdmin: v.ASN, + LocalData1: v.LocalData1, + LocalData2: v.LocalData2, + }) + } + return &LargeCommunitiesAttribute{ + Communities: communities, + } +} + +func (a *LargeCommunitiesAttribute) ToNative() (*bgp.PathAttributeLargeCommunities, error) { + communities := make([]*bgp.LargeCommunity, 0, len(a.Communities)) + for _, c := range a.Communities { + communities = append(communities, bgp.NewLargeCommunity(c.GlobalAdmin, c.LocalData1, c.LocalData2)) + } + return bgp.NewPathAttributeLargeCommunities(communities), nil +} + +func NewUnknownAttributeFromNative(a *bgp.PathAttributeUnknown) *UnknownAttribute { + return &UnknownAttribute{ + Flags: uint32(a.Flags), + Type: uint32(a.Type), + Value: a.Value, + } +} + +func (a *UnknownAttribute) ToNative() (*bgp.PathAttributeUnknown, error) { + return bgp.NewPathAttributeUnknown(bgp.BGPAttrFlag(a.Flags), bgp.BGPAttrType(a.Type), a.Value), nil +} + +func MarshalPathAttributes(attrList []bgp.PathAttributeInterface) []*any.Any { + anyList := make([]*any.Any, 0, len(attrList)) + for _, attr := range attrList { + switch a := attr.(type) { + case *bgp.PathAttributeOrigin: + n, _ := ptypes.MarshalAny(NewOriginAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeAsPath: + n, _ := ptypes.MarshalAny(NewAsPathAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeNextHop: + n, _ := ptypes.MarshalAny(NewNextHopAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeMultiExitDisc: + n, _ := ptypes.MarshalAny(NewMultiExitDiscAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeLocalPref: + n, _ := ptypes.MarshalAny(NewLocalPrefAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeAtomicAggregate: + n, _ := ptypes.MarshalAny(NewAtomicAggregateAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeAggregator: + n, _ := ptypes.MarshalAny(NewAggregatorAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeCommunities: + n, _ := ptypes.MarshalAny(NewCommunitiesAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeOriginatorId: + n, _ := ptypes.MarshalAny(NewOriginatorIdAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeClusterList: + n, _ := ptypes.MarshalAny(NewClusterListAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeMpReachNLRI: + n, _ := ptypes.MarshalAny(NewMpReachNLRIAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeMpUnreachNLRI: + n, _ := ptypes.MarshalAny(NewMpUnreachNLRIAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeExtendedCommunities: + n, _ := ptypes.MarshalAny(NewExtendedCommunitiesAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeAs4Path: + n, _ := ptypes.MarshalAny(NewAs4PathAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeAs4Aggregator: + n, _ := ptypes.MarshalAny(NewAs4AggregatorAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributePmsiTunnel: + n, _ := ptypes.MarshalAny(NewPmsiTunnelAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeTunnelEncap: + n, _ := ptypes.MarshalAny(NewTunnelEncapAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeIP6ExtendedCommunities: + n, _ := ptypes.MarshalAny(NewIP6ExtendedCommunitiesAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeAigp: + n, _ := ptypes.MarshalAny(NewAigpAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeLargeCommunities: + n, _ := ptypes.MarshalAny(NewLargeCommunitiesAttributeFromNative(a)) + anyList = append(anyList, n) + case *bgp.PathAttributeUnknown: + n, _ := ptypes.MarshalAny(NewUnknownAttributeFromNative(a)) + anyList = append(anyList, n) + } + } + return anyList +} + +func UnmarshalPathAttributes(values []*any.Any) ([]bgp.PathAttributeInterface, error) { + attrList := make([]bgp.PathAttributeInterface, 0, len(values)) + typeMap := make(map[bgp.BGPAttrType]struct{}) + for _, an := range values { + var attr bgp.PathAttributeInterface + var value ptypes.DynamicAny + err := ptypes.UnmarshalAny(an, &value) + if err != nil { + return nil, fmt.Errorf("failed to unmarshal path attribute: %s", err) + } + switch v := value.Message.(type) { + case *OriginAttribute: + attr, err = v.ToNative() + case *AsPathAttribute: + attr, err = v.ToNative() + case *NextHopAttribute: + attr, err = v.ToNative() + case *MultiExitDiscAttribute: + attr, err = v.ToNative() + case *LocalPrefAttribute: + attr, err = v.ToNative() + case *AtomicAggregateAttribute: + attr, err = v.ToNative() + case *AggregatorAttribute: + attr, err = v.ToNative() + case *CommunitiesAttribute: + attr, err = v.ToNative() + case *OriginatorIdAttribute: + attr, err = v.ToNative() + case *ClusterListAttribute: + attr, err = v.ToNative() + case *MpReachNLRIAttribute: + var nlri *bgp.PathAttributeMpReachNLRI + nlri, err = v.ToNative() + if len(nlri.Value) > 1 { + return nil, fmt.Errorf("multiple nlri in a single mp_reach_nlri are not supported") + } + attr = nlri + case *MpUnreachNLRIAttribute: + attr, err = v.ToNative() + case *ExtendedCommunitiesAttribute: + attr, err = v.ToNative() + case *As4PathAttribute: + attr, err = v.ToNative() + case *As4AggregatorAttribute: + attr, err = v.ToNative() + case *PmsiTunnelAttribute: + attr, err = v.ToNative() + case *TunnelEncapAttribute: + attr, err = v.ToNative() + case *IP6ExtendedCommunitiesAttribute: + attr, err = v.ToNative() + case *AigpAttribute: + attr, err = v.ToNative() + case *LargeCommunitiesAttribute: + attr, err = v.ToNative() + case *UnknownAttribute: + attr, err = v.ToNative() + } + if err != nil { + return nil, err + } + if attr == nil { + return nil, fmt.Errorf("invalid value type for path attribute: %s", value.Message) + } + if _, ok := typeMap[attr.GetType()]; ok { + return nil, fmt.Errorf("duplicated path attribute type: %d", attr.GetType()) + } + typeMap[attr.GetType()] = struct{}{} + attrList = append(attrList, attr) + } + return attrList, nil +} diff --git a/vendor/github.com/osrg/gobgp/api/attribute.pb.go b/vendor/github.com/osrg/gobgp/api/attribute.pb.go new file mode 100644 index 00000000..79535b7c --- /dev/null +++ b/vendor/github.com/osrg/gobgp/api/attribute.pb.go @@ -0,0 +1,2086 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: attribute.proto + +package gobgpapi + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import google_protobuf "github.com/golang/protobuf/ptypes/any" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type OriginAttribute struct { + Origin uint32 `protobuf:"varint,1,opt,name=origin" json:"origin,omitempty"` +} + +func (m *OriginAttribute) Reset() { *m = OriginAttribute{} } +func (m *OriginAttribute) String() string { return proto.CompactTextString(m) } +func (*OriginAttribute) ProtoMessage() {} +func (*OriginAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} } + +func (m *OriginAttribute) GetOrigin() uint32 { + if m != nil { + return m.Origin + } + return 0 +} + +type AsSegment struct { + Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + Numbers []uint32 `protobuf:"varint,2,rep,packed,name=numbers" json:"numbers,omitempty"` +} + +func (m *AsSegment) Reset() { *m = AsSegment{} } +func (m *AsSegment) String() string { return proto.CompactTextString(m) } +func (*AsSegment) ProtoMessage() {} +func (*AsSegment) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} } + +func (m *AsSegment) GetType() uint32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *AsSegment) GetNumbers() []uint32 { + if m != nil { + return m.Numbers + } + return nil +} + +type AsPathAttribute struct { + Segments []*AsSegment `protobuf:"bytes,1,rep,name=segments" json:"segments,omitempty"` +} + +func (m *AsPathAttribute) Reset() { *m = AsPathAttribute{} } +func (m *AsPathAttribute) String() string { return proto.CompactTextString(m) } +func (*AsPathAttribute) ProtoMessage() {} +func (*AsPathAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} } + +func (m *AsPathAttribute) GetSegments() []*AsSegment { + if m != nil { + return m.Segments + } + return nil +} + +type NextHopAttribute struct { + NextHop string `protobuf:"bytes,1,opt,name=next_hop,json=nextHop" json:"next_hop,omitempty"` +} + +func (m *NextHopAttribute) Reset() { *m = NextHopAttribute{} } +func (m *NextHopAttribute) String() string { return proto.CompactTextString(m) } +func (*NextHopAttribute) ProtoMessage() {} +func (*NextHopAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} } + +func (m *NextHopAttribute) GetNextHop() string { + if m != nil { + return m.NextHop + } + return "" +} + +type MultiExitDiscAttribute struct { + Med uint32 `protobuf:"varint,1,opt,name=med" json:"med,omitempty"` +} + +func (m *MultiExitDiscAttribute) Reset() { *m = MultiExitDiscAttribute{} } +func (m *MultiExitDiscAttribute) String() string { return proto.CompactTextString(m) } +func (*MultiExitDiscAttribute) ProtoMessage() {} +func (*MultiExitDiscAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} } + +func (m *MultiExitDiscAttribute) GetMed() uint32 { + if m != nil { + return m.Med + } + return 0 +} + +type LocalPrefAttribute struct { + LocalPref uint32 `protobuf:"varint,1,opt,name=local_pref,json=localPref" json:"local_pref,omitempty"` +} + +func (m *LocalPrefAttribute) Reset() { *m = LocalPrefAttribute{} } +func (m *LocalPrefAttribute) String() string { return proto.CompactTextString(m) } +func (*LocalPrefAttribute) ProtoMessage() {} +func (*LocalPrefAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{5} } + +func (m *LocalPrefAttribute) GetLocalPref() uint32 { + if m != nil { + return m.LocalPref + } + return 0 +} + +type AtomicAggregateAttribute struct { +} + +func (m *AtomicAggregateAttribute) Reset() { *m = AtomicAggregateAttribute{} } +func (m *AtomicAggregateAttribute) String() string { return proto.CompactTextString(m) } +func (*AtomicAggregateAttribute) ProtoMessage() {} +func (*AtomicAggregateAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{6} } + +type AggregatorAttribute struct { + As uint32 `protobuf:"varint,2,opt,name=as" json:"as,omitempty"` + Address string `protobuf:"bytes,3,opt,name=address" json:"address,omitempty"` +} + +func (m *AggregatorAttribute) Reset() { *m = AggregatorAttribute{} } +func (m *AggregatorAttribute) String() string { return proto.CompactTextString(m) } +func (*AggregatorAttribute) ProtoMessage() {} +func (*AggregatorAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{7} } + +func (m *AggregatorAttribute) GetAs() uint32 { + if m != nil { + return m.As + } + return 0 +} + +func (m *AggregatorAttribute) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +type CommunitiesAttribute struct { + Communities []uint32 `protobuf:"varint,1,rep,packed,name=communities" json:"communities,omitempty"` +} + +func (m *CommunitiesAttribute) Reset() { *m = CommunitiesAttribute{} } +func (m *CommunitiesAttribute) String() string { return proto.CompactTextString(m) } +func (*CommunitiesAttribute) ProtoMessage() {} +func (*CommunitiesAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{8} } + +func (m *CommunitiesAttribute) GetCommunities() []uint32 { + if m != nil { + return m.Communities + } + return nil +} + +type OriginatorIdAttribute struct { + Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` +} + +func (m *OriginatorIdAttribute) Reset() { *m = OriginatorIdAttribute{} } +func (m *OriginatorIdAttribute) String() string { return proto.CompactTextString(m) } +func (*OriginatorIdAttribute) ProtoMessage() {} +func (*OriginatorIdAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9} } + +func (m *OriginatorIdAttribute) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +type ClusterListAttribute struct { + Ids []string `protobuf:"bytes,1,rep,name=ids" json:"ids,omitempty"` +} + +func (m *ClusterListAttribute) Reset() { *m = ClusterListAttribute{} } +func (m *ClusterListAttribute) String() string { return proto.CompactTextString(m) } +func (*ClusterListAttribute) ProtoMessage() {} +func (*ClusterListAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10} } + +func (m *ClusterListAttribute) GetIds() []string { + if m != nil { + return m.Ids + } + return nil +} + +// IPAddressPrefix represents the NLRI for: +// - AFI=1, SAFI=1 +// - AFI=2, SAFI=1 +type IPAddressPrefix struct { + PrefixLen uint32 `protobuf:"varint,1,opt,name=prefix_len,json=prefixLen" json:"prefix_len,omitempty"` + Prefix string `protobuf:"bytes,2,opt,name=prefix" json:"prefix,omitempty"` +} + +func (m *IPAddressPrefix) Reset() { *m = IPAddressPrefix{} } +func (m *IPAddressPrefix) String() string { return proto.CompactTextString(m) } +func (*IPAddressPrefix) ProtoMessage() {} +func (*IPAddressPrefix) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{11} } + +func (m *IPAddressPrefix) GetPrefixLen() uint32 { + if m != nil { + return m.PrefixLen + } + return 0 +} + +func (m *IPAddressPrefix) GetPrefix() string { + if m != nil { + return m.Prefix + } + return "" +} + +// LabeledIPAddressPrefix represents the NLRI for: +// - AFI=1, SAFI=4 +// - AFI=2, SAFI=4 +type LabeledIPAddressPrefix struct { + Labels []uint32 `protobuf:"varint,1,rep,packed,name=labels" json:"labels,omitempty"` + PrefixLen uint32 `protobuf:"varint,2,opt,name=prefix_len,json=prefixLen" json:"prefix_len,omitempty"` + Prefix string `protobuf:"bytes,3,opt,name=prefix" json:"prefix,omitempty"` +} + +func (m *LabeledIPAddressPrefix) Reset() { *m = LabeledIPAddressPrefix{} } +func (m *LabeledIPAddressPrefix) String() string { return proto.CompactTextString(m) } +func (*LabeledIPAddressPrefix) ProtoMessage() {} +func (*LabeledIPAddressPrefix) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{12} } + +func (m *LabeledIPAddressPrefix) GetLabels() []uint32 { + if m != nil { + return m.Labels + } + return nil +} + +func (m *LabeledIPAddressPrefix) GetPrefixLen() uint32 { + if m != nil { + return m.PrefixLen + } + return 0 +} + +func (m *LabeledIPAddressPrefix) GetPrefix() string { + if m != nil { + return m.Prefix + } + return "" +} + +// EncapsulationNLRI represents the NLRI for: +// - AFI=1, SAFI=7 +// - AFI=2, SAFI=7 +type EncapsulationNLRI struct { + Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` +} + +func (m *EncapsulationNLRI) Reset() { *m = EncapsulationNLRI{} } +func (m *EncapsulationNLRI) String() string { return proto.CompactTextString(m) } +func (*EncapsulationNLRI) ProtoMessage() {} +func (*EncapsulationNLRI) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{13} } + +func (m *EncapsulationNLRI) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +type RouteDistinguisherTwoOctetAS struct { + Admin uint32 `protobuf:"varint,1,opt,name=admin" json:"admin,omitempty"` + Assigned uint32 `protobuf:"varint,2,opt,name=assigned" json:"assigned,omitempty"` +} + +func (m *RouteDistinguisherTwoOctetAS) Reset() { *m = RouteDistinguisherTwoOctetAS{} } +func (m *RouteDistinguisherTwoOctetAS) String() string { return proto.CompactTextString(m) } +func (*RouteDistinguisherTwoOctetAS) ProtoMessage() {} +func (*RouteDistinguisherTwoOctetAS) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{14} } + +func (m *RouteDistinguisherTwoOctetAS) GetAdmin() uint32 { + if m != nil { + return m.Admin + } + return 0 +} + +func (m *RouteDistinguisherTwoOctetAS) GetAssigned() uint32 { + if m != nil { + return m.Assigned + } + return 0 +} + +type RouteDistinguisherIPAddress struct { + Admin string `protobuf:"bytes,1,opt,name=admin" json:"admin,omitempty"` + Assigned uint32 `protobuf:"varint,2,opt,name=assigned" json:"assigned,omitempty"` +} + +func (m *RouteDistinguisherIPAddress) Reset() { *m = RouteDistinguisherIPAddress{} } +func (m *RouteDistinguisherIPAddress) String() string { return proto.CompactTextString(m) } +func (*RouteDistinguisherIPAddress) ProtoMessage() {} +func (*RouteDistinguisherIPAddress) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{15} } + +func (m *RouteDistinguisherIPAddress) GetAdmin() string { + if m != nil { + return m.Admin + } + return "" +} + +func (m *RouteDistinguisherIPAddress) GetAssigned() uint32 { + if m != nil { + return m.Assigned + } + return 0 +} + +type RouteDistinguisherFourOctetAS struct { + Admin uint32 `protobuf:"varint,1,opt,name=admin" json:"admin,omitempty"` + Assigned uint32 `protobuf:"varint,2,opt,name=assigned" json:"assigned,omitempty"` +} + +func (m *RouteDistinguisherFourOctetAS) Reset() { *m = RouteDistinguisherFourOctetAS{} } +func (m *RouteDistinguisherFourOctetAS) String() string { return proto.CompactTextString(m) } +func (*RouteDistinguisherFourOctetAS) ProtoMessage() {} +func (*RouteDistinguisherFourOctetAS) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{16} } + +func (m *RouteDistinguisherFourOctetAS) GetAdmin() uint32 { + if m != nil { + return m.Admin + } + return 0 +} + +func (m *RouteDistinguisherFourOctetAS) GetAssigned() uint32 { + if m != nil { + return m.Assigned + } + return 0 +} + +type EthernetSegmentIdentifier struct { + Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *EthernetSegmentIdentifier) Reset() { *m = EthernetSegmentIdentifier{} } +func (m *EthernetSegmentIdentifier) String() string { return proto.CompactTextString(m) } +func (*EthernetSegmentIdentifier) ProtoMessage() {} +func (*EthernetSegmentIdentifier) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{17} } + +func (m *EthernetSegmentIdentifier) GetType() uint32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *EthernetSegmentIdentifier) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// EVPNEthernetAutoDiscoveryRoute represents the NLRI for: +// - AFI=25, SAFI=70, RouteType=1 +type EVPNEthernetAutoDiscoveryRoute struct { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + Rd *google_protobuf.Any `protobuf:"bytes,1,opt,name=rd" json:"rd,omitempty"` + Esi *EthernetSegmentIdentifier `protobuf:"bytes,2,opt,name=esi" json:"esi,omitempty"` + EthernetTag uint32 `protobuf:"varint,3,opt,name=ethernet_tag,json=ethernetTag" json:"ethernet_tag,omitempty"` + Label uint32 `protobuf:"varint,4,opt,name=label" json:"label,omitempty"` +} + +func (m *EVPNEthernetAutoDiscoveryRoute) Reset() { *m = EVPNEthernetAutoDiscoveryRoute{} } +func (m *EVPNEthernetAutoDiscoveryRoute) String() string { return proto.CompactTextString(m) } +func (*EVPNEthernetAutoDiscoveryRoute) ProtoMessage() {} +func (*EVPNEthernetAutoDiscoveryRoute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{18} } + +func (m *EVPNEthernetAutoDiscoveryRoute) GetRd() *google_protobuf.Any { + if m != nil { + return m.Rd + } + return nil +} + +func (m *EVPNEthernetAutoDiscoveryRoute) GetEsi() *EthernetSegmentIdentifier { + if m != nil { + return m.Esi + } + return nil +} + +func (m *EVPNEthernetAutoDiscoveryRoute) GetEthernetTag() uint32 { + if m != nil { + return m.EthernetTag + } + return 0 +} + +func (m *EVPNEthernetAutoDiscoveryRoute) GetLabel() uint32 { + if m != nil { + return m.Label + } + return 0 +} + +// EVPNMACIPAdvertisementRoute represents the NLRI for: +// - AFI=25, SAFI=70, RouteType=2 +type EVPNMACIPAdvertisementRoute struct { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + Rd *google_protobuf.Any `protobuf:"bytes,1,opt,name=rd" json:"rd,omitempty"` + Esi *EthernetSegmentIdentifier `protobuf:"bytes,2,opt,name=esi" json:"esi,omitempty"` + EthernetTag uint32 `protobuf:"varint,3,opt,name=ethernet_tag,json=ethernetTag" json:"ethernet_tag,omitempty"` + MacAddress string `protobuf:"bytes,4,opt,name=mac_address,json=macAddress" json:"mac_address,omitempty"` + IpAddress string `protobuf:"bytes,5,opt,name=ip_address,json=ipAddress" json:"ip_address,omitempty"` + Labels []uint32 `protobuf:"varint,6,rep,packed,name=labels" json:"labels,omitempty"` +} + +func (m *EVPNMACIPAdvertisementRoute) Reset() { *m = EVPNMACIPAdvertisementRoute{} } +func (m *EVPNMACIPAdvertisementRoute) String() string { return proto.CompactTextString(m) } +func (*EVPNMACIPAdvertisementRoute) ProtoMessage() {} +func (*EVPNMACIPAdvertisementRoute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{19} } + +func (m *EVPNMACIPAdvertisementRoute) GetRd() *google_protobuf.Any { + if m != nil { + return m.Rd + } + return nil +} + +func (m *EVPNMACIPAdvertisementRoute) GetEsi() *EthernetSegmentIdentifier { + if m != nil { + return m.Esi + } + return nil +} + +func (m *EVPNMACIPAdvertisementRoute) GetEthernetTag() uint32 { + if m != nil { + return m.EthernetTag + } + return 0 +} + +func (m *EVPNMACIPAdvertisementRoute) GetMacAddress() string { + if m != nil { + return m.MacAddress + } + return "" +} + +func (m *EVPNMACIPAdvertisementRoute) GetIpAddress() string { + if m != nil { + return m.IpAddress + } + return "" +} + +func (m *EVPNMACIPAdvertisementRoute) GetLabels() []uint32 { + if m != nil { + return m.Labels + } + return nil +} + +// EVPNInclusiveMulticastEthernetTagRoute represents the NLRI for: +// - AFI=25, SAFI=70, RouteType=3 +type EVPNInclusiveMulticastEthernetTagRoute struct { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + Rd *google_protobuf.Any `protobuf:"bytes,1,opt,name=rd" json:"rd,omitempty"` + EthernetTag uint32 `protobuf:"varint,2,opt,name=ethernet_tag,json=ethernetTag" json:"ethernet_tag,omitempty"` + IpAddress string `protobuf:"bytes,3,opt,name=ip_address,json=ipAddress" json:"ip_address,omitempty"` +} + +func (m *EVPNInclusiveMulticastEthernetTagRoute) Reset() { + *m = EVPNInclusiveMulticastEthernetTagRoute{} +} +func (m *EVPNInclusiveMulticastEthernetTagRoute) String() string { return proto.CompactTextString(m) } +func (*EVPNInclusiveMulticastEthernetTagRoute) ProtoMessage() {} +func (*EVPNInclusiveMulticastEthernetTagRoute) Descriptor() ([]byte, []int) { + return fileDescriptor1, []int{20} +} + +func (m *EVPNInclusiveMulticastEthernetTagRoute) GetRd() *google_protobuf.Any { + if m != nil { + return m.Rd + } + return nil +} + +func (m *EVPNInclusiveMulticastEthernetTagRoute) GetEthernetTag() uint32 { + if m != nil { + return m.EthernetTag + } + return 0 +} + +func (m *EVPNInclusiveMulticastEthernetTagRoute) GetIpAddress() string { + if m != nil { + return m.IpAddress + } + return "" +} + +// EVPNEthernetSegmentRoute represents the NLRI for: +// - AFI=25, SAFI=70, RouteType=4 +type EVPNEthernetSegmentRoute struct { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + Rd *google_protobuf.Any `protobuf:"bytes,1,opt,name=rd" json:"rd,omitempty"` + Esi *EthernetSegmentIdentifier `protobuf:"bytes,2,opt,name=esi" json:"esi,omitempty"` + IpAddress string `protobuf:"bytes,3,opt,name=ip_address,json=ipAddress" json:"ip_address,omitempty"` +} + +func (m *EVPNEthernetSegmentRoute) Reset() { *m = EVPNEthernetSegmentRoute{} } +func (m *EVPNEthernetSegmentRoute) String() string { return proto.CompactTextString(m) } +func (*EVPNEthernetSegmentRoute) ProtoMessage() {} +func (*EVPNEthernetSegmentRoute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{21} } + +func (m *EVPNEthernetSegmentRoute) GetRd() *google_protobuf.Any { + if m != nil { + return m.Rd + } + return nil +} + +func (m *EVPNEthernetSegmentRoute) GetEsi() *EthernetSegmentIdentifier { + if m != nil { + return m.Esi + } + return nil +} + +func (m *EVPNEthernetSegmentRoute) GetIpAddress() string { + if m != nil { + return m.IpAddress + } + return "" +} + +// EVPNIPPrefixRoute represents the NLRI for: +// - AFI=25, SAFI=70, RouteType=5 +type EVPNIPPrefixRoute struct { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + Rd *google_protobuf.Any `protobuf:"bytes,1,opt,name=rd" json:"rd,omitempty"` + Esi *EthernetSegmentIdentifier `protobuf:"bytes,2,opt,name=esi" json:"esi,omitempty"` + EthernetTag uint32 `protobuf:"varint,3,opt,name=ethernet_tag,json=ethernetTag" json:"ethernet_tag,omitempty"` + IpPrefix string `protobuf:"bytes,4,opt,name=ip_prefix,json=ipPrefix" json:"ip_prefix,omitempty"` + IpPrefixLen uint32 `protobuf:"varint,5,opt,name=ip_prefix_len,json=ipPrefixLen" json:"ip_prefix_len,omitempty"` + GwAddress string `protobuf:"bytes,6,opt,name=gw_address,json=gwAddress" json:"gw_address,omitempty"` + Label uint32 `protobuf:"varint,7,opt,name=label" json:"label,omitempty"` +} + +func (m *EVPNIPPrefixRoute) Reset() { *m = EVPNIPPrefixRoute{} } +func (m *EVPNIPPrefixRoute) String() string { return proto.CompactTextString(m) } +func (*EVPNIPPrefixRoute) ProtoMessage() {} +func (*EVPNIPPrefixRoute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{22} } + +func (m *EVPNIPPrefixRoute) GetRd() *google_protobuf.Any { + if m != nil { + return m.Rd + } + return nil +} + +func (m *EVPNIPPrefixRoute) GetEsi() *EthernetSegmentIdentifier { + if m != nil { + return m.Esi + } + return nil +} + +func (m *EVPNIPPrefixRoute) GetEthernetTag() uint32 { + if m != nil { + return m.EthernetTag + } + return 0 +} + +func (m *EVPNIPPrefixRoute) GetIpPrefix() string { + if m != nil { + return m.IpPrefix + } + return "" +} + +func (m *EVPNIPPrefixRoute) GetIpPrefixLen() uint32 { + if m != nil { + return m.IpPrefixLen + } + return 0 +} + +func (m *EVPNIPPrefixRoute) GetGwAddress() string { + if m != nil { + return m.GwAddress + } + return "" +} + +func (m *EVPNIPPrefixRoute) GetLabel() uint32 { + if m != nil { + return m.Label + } + return 0 +} + +// LabeledVPNIPAddressPrefix represents the NLRI for: +// - AFI=1, SAFI=128 +// - AFI=2, SAFI=128 +type LabeledVPNIPAddressPrefix struct { + Labels []uint32 `protobuf:"varint,1,rep,packed,name=labels" json:"labels,omitempty"` + // One of: + // - TwoOctetAsSpecificExtended + // - IPv4AddressSpecificExtended + // - FourOctetAsSpecificExtended + Rd *google_protobuf.Any `protobuf:"bytes,2,opt,name=rd" json:"rd,omitempty"` + PrefixLen uint32 `protobuf:"varint,3,opt,name=prefix_len,json=prefixLen" json:"prefix_len,omitempty"` + Prefix string `protobuf:"bytes,4,opt,name=prefix" json:"prefix,omitempty"` +} + +func (m *LabeledVPNIPAddressPrefix) Reset() { *m = LabeledVPNIPAddressPrefix{} } +func (m *LabeledVPNIPAddressPrefix) String() string { return proto.CompactTextString(m) } +func (*LabeledVPNIPAddressPrefix) ProtoMessage() {} +func (*LabeledVPNIPAddressPrefix) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{23} } + +func (m *LabeledVPNIPAddressPrefix) GetLabels() []uint32 { + if m != nil { + return m.Labels + } + return nil +} + +func (m *LabeledVPNIPAddressPrefix) GetRd() *google_protobuf.Any { + if m != nil { + return m.Rd + } + return nil +} + +func (m *LabeledVPNIPAddressPrefix) GetPrefixLen() uint32 { + if m != nil { + return m.PrefixLen + } + return 0 +} + +func (m *LabeledVPNIPAddressPrefix) GetPrefix() string { + if m != nil { + return m.Prefix + } + return "" +} + +// RouteTargetMembershipNLRI represents the NLRI for: +// - AFI=1, SAFI=132 +type RouteTargetMembershipNLRI struct { + As uint32 `protobuf:"varint,1,opt,name=as" json:"as,omitempty"` + // One of: + // - TwoOctetAsSpecificExtended + // - IPv4AddressSpecificExtended + // - FourOctetAsSpecificExtended + Rt *google_protobuf.Any `protobuf:"bytes,2,opt,name=rt" json:"rt,omitempty"` +} + +func (m *RouteTargetMembershipNLRI) Reset() { *m = RouteTargetMembershipNLRI{} } +func (m *RouteTargetMembershipNLRI) String() string { return proto.CompactTextString(m) } +func (*RouteTargetMembershipNLRI) ProtoMessage() {} +func (*RouteTargetMembershipNLRI) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{24} } + +func (m *RouteTargetMembershipNLRI) GetAs() uint32 { + if m != nil { + return m.As + } + return 0 +} + +func (m *RouteTargetMembershipNLRI) GetRt() *google_protobuf.Any { + if m != nil { + return m.Rt + } + return nil +} + +type FlowSpecIPPrefix struct { + Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + PrefixLen uint32 `protobuf:"varint,2,opt,name=prefix_len,json=prefixLen" json:"prefix_len,omitempty"` + Prefix string `protobuf:"bytes,3,opt,name=prefix" json:"prefix,omitempty"` + // IPv6 only + Offset uint32 `protobuf:"varint,4,opt,name=offset" json:"offset,omitempty"` +} + +func (m *FlowSpecIPPrefix) Reset() { *m = FlowSpecIPPrefix{} } +func (m *FlowSpecIPPrefix) String() string { return proto.CompactTextString(m) } +func (*FlowSpecIPPrefix) ProtoMessage() {} +func (*FlowSpecIPPrefix) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{25} } + +func (m *FlowSpecIPPrefix) GetType() uint32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *FlowSpecIPPrefix) GetPrefixLen() uint32 { + if m != nil { + return m.PrefixLen + } + return 0 +} + +func (m *FlowSpecIPPrefix) GetPrefix() string { + if m != nil { + return m.Prefix + } + return "" +} + +func (m *FlowSpecIPPrefix) GetOffset() uint32 { + if m != nil { + return m.Offset + } + return 0 +} + +type FlowSpecMAC struct { + Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + Address string `protobuf:"bytes,2,opt,name=address" json:"address,omitempty"` +} + +func (m *FlowSpecMAC) Reset() { *m = FlowSpecMAC{} } +func (m *FlowSpecMAC) String() string { return proto.CompactTextString(m) } +func (*FlowSpecMAC) ProtoMessage() {} +func (*FlowSpecMAC) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{26} } + +func (m *FlowSpecMAC) GetType() uint32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *FlowSpecMAC) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +type FlowSpecComponentItem struct { + // Operator for Numeric type, Operand for Bitmask type + Op uint32 `protobuf:"varint,1,opt,name=op" json:"op,omitempty"` + Value uint64 `protobuf:"varint,2,opt,name=value" json:"value,omitempty"` +} + +func (m *FlowSpecComponentItem) Reset() { *m = FlowSpecComponentItem{} } +func (m *FlowSpecComponentItem) String() string { return proto.CompactTextString(m) } +func (*FlowSpecComponentItem) ProtoMessage() {} +func (*FlowSpecComponentItem) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{27} } + +func (m *FlowSpecComponentItem) GetOp() uint32 { + if m != nil { + return m.Op + } + return 0 +} + +func (m *FlowSpecComponentItem) GetValue() uint64 { + if m != nil { + return m.Value + } + return 0 +} + +type FlowSpecComponent struct { + Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + Items []*FlowSpecComponentItem `protobuf:"bytes,2,rep,name=items" json:"items,omitempty"` +} + +func (m *FlowSpecComponent) Reset() { *m = FlowSpecComponent{} } +func (m *FlowSpecComponent) String() string { return proto.CompactTextString(m) } +func (*FlowSpecComponent) ProtoMessage() {} +func (*FlowSpecComponent) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{28} } + +func (m *FlowSpecComponent) GetType() uint32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *FlowSpecComponent) GetItems() []*FlowSpecComponentItem { + if m != nil { + return m.Items + } + return nil +} + +// FlowSpecNLRI represents the NLRI for: +// - AFI=1, SAFI=133 +// - AFI=2, SAFI=133 +type FlowSpecNLRI struct { + // One of: + // - FlowSpecIPPrefix + // - FlowSpecMAC + // - FlowSpecComponent + Rules []*google_protobuf.Any `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"` +} + +func (m *FlowSpecNLRI) Reset() { *m = FlowSpecNLRI{} } +func (m *FlowSpecNLRI) String() string { return proto.CompactTextString(m) } +func (*FlowSpecNLRI) ProtoMessage() {} +func (*FlowSpecNLRI) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{29} } + +func (m *FlowSpecNLRI) GetRules() []*google_protobuf.Any { + if m != nil { + return m.Rules + } + return nil +} + +// VPNFlowSpecNLRI represents the NLRI for: +// - AFI=1, SAFI=134 +// - AFI=2, SAFI=134 +// - AFI=25, SAFI=134 +type VPNFlowSpecNLRI struct { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + Rd *google_protobuf.Any `protobuf:"bytes,1,opt,name=rd" json:"rd,omitempty"` + // One of: + // - FlowSpecIPPrefix + // - FlowSpecMAC + // - FlowSpecComponent + Rules []*google_protobuf.Any `protobuf:"bytes,2,rep,name=rules" json:"rules,omitempty"` +} + +func (m *VPNFlowSpecNLRI) Reset() { *m = VPNFlowSpecNLRI{} } +func (m *VPNFlowSpecNLRI) String() string { return proto.CompactTextString(m) } +func (*VPNFlowSpecNLRI) ProtoMessage() {} +func (*VPNFlowSpecNLRI) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{30} } + +func (m *VPNFlowSpecNLRI) GetRd() *google_protobuf.Any { + if m != nil { + return m.Rd + } + return nil +} + +func (m *VPNFlowSpecNLRI) GetRules() []*google_protobuf.Any { + if m != nil { + return m.Rules + } + return nil +} + +// OpaqueNLRI represents the NLRI for: +// - AFI=16397, SAFI=241 +type OpaqueNLRI struct { + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *OpaqueNLRI) Reset() { *m = OpaqueNLRI{} } +func (m *OpaqueNLRI) String() string { return proto.CompactTextString(m) } +func (*OpaqueNLRI) ProtoMessage() {} +func (*OpaqueNLRI) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{31} } + +func (m *OpaqueNLRI) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +func (m *OpaqueNLRI) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +type MpReachNLRIAttribute struct { + Family uint32 `protobuf:"varint,1,opt,name=family" json:"family,omitempty"` + NextHops []string `protobuf:"bytes,2,rep,name=next_hops,json=nextHops" json:"next_hops,omitempty"` + // Each NLRI must be one of: + // - IPAddressPrefix + // - LabeledIPAddressPrefix + // - EncapsulationNLRI + // - EVPNEthernetAutoDiscoveryRoute + // - EVPNMACIPAdvertisementRoute + // - EVPNInclusiveMulticastEthernetTagRoute + // - EVPNEthernetSegmentRoute + // - EVPNIPPrefixRoute + // - LabeledVPNIPAddressPrefix + // - RouteTargetMembershipNLRI + // - FlowSpecNLRI + // - VPNFlowSpecNLRI + // - OpaqueNLRI + Nlris []*google_protobuf.Any `protobuf:"bytes,3,rep,name=nlris" json:"nlris,omitempty"` +} + +func (m *MpReachNLRIAttribute) Reset() { *m = MpReachNLRIAttribute{} } +func (m *MpReachNLRIAttribute) String() string { return proto.CompactTextString(m) } +func (*MpReachNLRIAttribute) ProtoMessage() {} +func (*MpReachNLRIAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{32} } + +func (m *MpReachNLRIAttribute) GetFamily() uint32 { + if m != nil { + return m.Family + } + return 0 +} + +func (m *MpReachNLRIAttribute) GetNextHops() []string { + if m != nil { + return m.NextHops + } + return nil +} + +func (m *MpReachNLRIAttribute) GetNlris() []*google_protobuf.Any { + if m != nil { + return m.Nlris + } + return nil +} + +type MpUnreachNLRIAttribute struct { + Family uint32 `protobuf:"varint,1,opt,name=family" json:"family,omitempty"` + // The same as NLRI field of MpReachNLRIAttribute + Nlris []*google_protobuf.Any `protobuf:"bytes,3,rep,name=nlris" json:"nlris,omitempty"` +} + +func (m *MpUnreachNLRIAttribute) Reset() { *m = MpUnreachNLRIAttribute{} } +func (m *MpUnreachNLRIAttribute) String() string { return proto.CompactTextString(m) } +func (*MpUnreachNLRIAttribute) ProtoMessage() {} +func (*MpUnreachNLRIAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{33} } + +func (m *MpUnreachNLRIAttribute) GetFamily() uint32 { + if m != nil { + return m.Family + } + return 0 +} + +func (m *MpUnreachNLRIAttribute) GetNlris() []*google_protobuf.Any { + if m != nil { + return m.Nlris + } + return nil +} + +type TwoOctetAsSpecificExtended struct { + IsTransitive bool `protobuf:"varint,1,opt,name=is_transitive,json=isTransitive" json:"is_transitive,omitempty"` + SubType uint32 `protobuf:"varint,2,opt,name=sub_type,json=subType" json:"sub_type,omitempty"` + As uint32 `protobuf:"varint,3,opt,name=as" json:"as,omitempty"` + LocalAdmin uint32 `protobuf:"varint,4,opt,name=local_admin,json=localAdmin" json:"local_admin,omitempty"` +} + +func (m *TwoOctetAsSpecificExtended) Reset() { *m = TwoOctetAsSpecificExtended{} } +func (m *TwoOctetAsSpecificExtended) String() string { return proto.CompactTextString(m) } +func (*TwoOctetAsSpecificExtended) ProtoMessage() {} +func (*TwoOctetAsSpecificExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{34} } + +func (m *TwoOctetAsSpecificExtended) GetIsTransitive() bool { + if m != nil { + return m.IsTransitive + } + return false +} + +func (m *TwoOctetAsSpecificExtended) GetSubType() uint32 { + if m != nil { + return m.SubType + } + return 0 +} + +func (m *TwoOctetAsSpecificExtended) GetAs() uint32 { + if m != nil { + return m.As + } + return 0 +} + +func (m *TwoOctetAsSpecificExtended) GetLocalAdmin() uint32 { + if m != nil { + return m.LocalAdmin + } + return 0 +} + +type IPv4AddressSpecificExtended struct { + IsTransitive bool `protobuf:"varint,1,opt,name=is_transitive,json=isTransitive" json:"is_transitive,omitempty"` + SubType uint32 `protobuf:"varint,2,opt,name=sub_type,json=subType" json:"sub_type,omitempty"` + Address string `protobuf:"bytes,3,opt,name=address" json:"address,omitempty"` + LocalAdmin uint32 `protobuf:"varint,4,opt,name=local_admin,json=localAdmin" json:"local_admin,omitempty"` +} + +func (m *IPv4AddressSpecificExtended) Reset() { *m = IPv4AddressSpecificExtended{} } +func (m *IPv4AddressSpecificExtended) String() string { return proto.CompactTextString(m) } +func (*IPv4AddressSpecificExtended) ProtoMessage() {} +func (*IPv4AddressSpecificExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{35} } + +func (m *IPv4AddressSpecificExtended) GetIsTransitive() bool { + if m != nil { + return m.IsTransitive + } + return false +} + +func (m *IPv4AddressSpecificExtended) GetSubType() uint32 { + if m != nil { + return m.SubType + } + return 0 +} + +func (m *IPv4AddressSpecificExtended) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *IPv4AddressSpecificExtended) GetLocalAdmin() uint32 { + if m != nil { + return m.LocalAdmin + } + return 0 +} + +type FourOctetAsSpecificExtended struct { + IsTransitive bool `protobuf:"varint,1,opt,name=is_transitive,json=isTransitive" json:"is_transitive,omitempty"` + SubType uint32 `protobuf:"varint,2,opt,name=sub_type,json=subType" json:"sub_type,omitempty"` + As uint32 `protobuf:"varint,3,opt,name=as" json:"as,omitempty"` + LocalAdmin uint32 `protobuf:"varint,4,opt,name=local_admin,json=localAdmin" json:"local_admin,omitempty"` +} + +func (m *FourOctetAsSpecificExtended) Reset() { *m = FourOctetAsSpecificExtended{} } +func (m *FourOctetAsSpecificExtended) String() string { return proto.CompactTextString(m) } +func (*FourOctetAsSpecificExtended) ProtoMessage() {} +func (*FourOctetAsSpecificExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{36} } + +func (m *FourOctetAsSpecificExtended) GetIsTransitive() bool { + if m != nil { + return m.IsTransitive + } + return false +} + +func (m *FourOctetAsSpecificExtended) GetSubType() uint32 { + if m != nil { + return m.SubType + } + return 0 +} + +func (m *FourOctetAsSpecificExtended) GetAs() uint32 { + if m != nil { + return m.As + } + return 0 +} + +func (m *FourOctetAsSpecificExtended) GetLocalAdmin() uint32 { + if m != nil { + return m.LocalAdmin + } + return 0 +} + +type ValidationExtended struct { + State uint32 `protobuf:"varint,1,opt,name=state" json:"state,omitempty"` +} + +func (m *ValidationExtended) Reset() { *m = ValidationExtended{} } +func (m *ValidationExtended) String() string { return proto.CompactTextString(m) } +func (*ValidationExtended) ProtoMessage() {} +func (*ValidationExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{37} } + +func (m *ValidationExtended) GetState() uint32 { + if m != nil { + return m.State + } + return 0 +} + +type ColorExtended struct { + Color uint32 `protobuf:"varint,1,opt,name=color" json:"color,omitempty"` +} + +func (m *ColorExtended) Reset() { *m = ColorExtended{} } +func (m *ColorExtended) String() string { return proto.CompactTextString(m) } +func (*ColorExtended) ProtoMessage() {} +func (*ColorExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{38} } + +func (m *ColorExtended) GetColor() uint32 { + if m != nil { + return m.Color + } + return 0 +} + +type EncapExtended struct { + TunnelType uint32 `protobuf:"varint,1,opt,name=tunnel_type,json=tunnelType" json:"tunnel_type,omitempty"` +} + +func (m *EncapExtended) Reset() { *m = EncapExtended{} } +func (m *EncapExtended) String() string { return proto.CompactTextString(m) } +func (*EncapExtended) ProtoMessage() {} +func (*EncapExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{39} } + +func (m *EncapExtended) GetTunnelType() uint32 { + if m != nil { + return m.TunnelType + } + return 0 +} + +type DefaultGatewayExtended struct { +} + +func (m *DefaultGatewayExtended) Reset() { *m = DefaultGatewayExtended{} } +func (m *DefaultGatewayExtended) String() string { return proto.CompactTextString(m) } +func (*DefaultGatewayExtended) ProtoMessage() {} +func (*DefaultGatewayExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{40} } + +type OpaqueExtended struct { + IsTransitive bool `protobuf:"varint,1,opt,name=is_transitive,json=isTransitive" json:"is_transitive,omitempty"` + Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *OpaqueExtended) Reset() { *m = OpaqueExtended{} } +func (m *OpaqueExtended) String() string { return proto.CompactTextString(m) } +func (*OpaqueExtended) ProtoMessage() {} +func (*OpaqueExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{41} } + +func (m *OpaqueExtended) GetIsTransitive() bool { + if m != nil { + return m.IsTransitive + } + return false +} + +func (m *OpaqueExtended) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +type ESILabelExtended struct { + IsSingleActive bool `protobuf:"varint,1,opt,name=is_single_active,json=isSingleActive" json:"is_single_active,omitempty"` + Label uint32 `protobuf:"varint,2,opt,name=label" json:"label,omitempty"` +} + +func (m *ESILabelExtended) Reset() { *m = ESILabelExtended{} } +func (m *ESILabelExtended) String() string { return proto.CompactTextString(m) } +func (*ESILabelExtended) ProtoMessage() {} +func (*ESILabelExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{42} } + +func (m *ESILabelExtended) GetIsSingleActive() bool { + if m != nil { + return m.IsSingleActive + } + return false +} + +func (m *ESILabelExtended) GetLabel() uint32 { + if m != nil { + return m.Label + } + return 0 +} + +type ESImportRouteTarget struct { + EsImport string `protobuf:"bytes,1,opt,name=es_import,json=esImport" json:"es_import,omitempty"` +} + +func (m *ESImportRouteTarget) Reset() { *m = ESImportRouteTarget{} } +func (m *ESImportRouteTarget) String() string { return proto.CompactTextString(m) } +func (*ESImportRouteTarget) ProtoMessage() {} +func (*ESImportRouteTarget) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{43} } + +func (m *ESImportRouteTarget) GetEsImport() string { + if m != nil { + return m.EsImport + } + return "" +} + +type MacMobilityExtended struct { + IsSticky bool `protobuf:"varint,1,opt,name=is_sticky,json=isSticky" json:"is_sticky,omitempty"` + SequenceNum uint32 `protobuf:"varint,2,opt,name=sequence_num,json=sequenceNum" json:"sequence_num,omitempty"` +} + +func (m *MacMobilityExtended) Reset() { *m = MacMobilityExtended{} } +func (m *MacMobilityExtended) String() string { return proto.CompactTextString(m) } +func (*MacMobilityExtended) ProtoMessage() {} +func (*MacMobilityExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{44} } + +func (m *MacMobilityExtended) GetIsSticky() bool { + if m != nil { + return m.IsSticky + } + return false +} + +func (m *MacMobilityExtended) GetSequenceNum() uint32 { + if m != nil { + return m.SequenceNum + } + return 0 +} + +type RouterMacExtended struct { + Mac string `protobuf:"bytes,1,opt,name=mac" json:"mac,omitempty"` +} + +func (m *RouterMacExtended) Reset() { *m = RouterMacExtended{} } +func (m *RouterMacExtended) String() string { return proto.CompactTextString(m) } +func (*RouterMacExtended) ProtoMessage() {} +func (*RouterMacExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{45} } + +func (m *RouterMacExtended) GetMac() string { + if m != nil { + return m.Mac + } + return "" +} + +type TrafficRateExtended struct { + As uint32 `protobuf:"varint,1,opt,name=as" json:"as,omitempty"` + Rate float32 `protobuf:"fixed32,2,opt,name=rate" json:"rate,omitempty"` +} + +func (m *TrafficRateExtended) Reset() { *m = TrafficRateExtended{} } +func (m *TrafficRateExtended) String() string { return proto.CompactTextString(m) } +func (*TrafficRateExtended) ProtoMessage() {} +func (*TrafficRateExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{46} } + +func (m *TrafficRateExtended) GetAs() uint32 { + if m != nil { + return m.As + } + return 0 +} + +func (m *TrafficRateExtended) GetRate() float32 { + if m != nil { + return m.Rate + } + return 0 +} + +type TrafficActionExtended struct { + Terminal bool `protobuf:"varint,1,opt,name=terminal" json:"terminal,omitempty"` + Sample bool `protobuf:"varint,2,opt,name=sample" json:"sample,omitempty"` +} + +func (m *TrafficActionExtended) Reset() { *m = TrafficActionExtended{} } +func (m *TrafficActionExtended) String() string { return proto.CompactTextString(m) } +func (*TrafficActionExtended) ProtoMessage() {} +func (*TrafficActionExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{47} } + +func (m *TrafficActionExtended) GetTerminal() bool { + if m != nil { + return m.Terminal + } + return false +} + +func (m *TrafficActionExtended) GetSample() bool { + if m != nil { + return m.Sample + } + return false +} + +type RedirectTwoOctetAsSpecificExtended struct { + As uint32 `protobuf:"varint,1,opt,name=as" json:"as,omitempty"` + LocalAdmin uint32 `protobuf:"varint,2,opt,name=local_admin,json=localAdmin" json:"local_admin,omitempty"` +} + +func (m *RedirectTwoOctetAsSpecificExtended) Reset() { *m = RedirectTwoOctetAsSpecificExtended{} } +func (m *RedirectTwoOctetAsSpecificExtended) String() string { return proto.CompactTextString(m) } +func (*RedirectTwoOctetAsSpecificExtended) ProtoMessage() {} +func (*RedirectTwoOctetAsSpecificExtended) Descriptor() ([]byte, []int) { + return fileDescriptor1, []int{48} +} + +func (m *RedirectTwoOctetAsSpecificExtended) GetAs() uint32 { + if m != nil { + return m.As + } + return 0 +} + +func (m *RedirectTwoOctetAsSpecificExtended) GetLocalAdmin() uint32 { + if m != nil { + return m.LocalAdmin + } + return 0 +} + +type RedirectIPv4AddressSpecificExtended struct { + Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` + LocalAdmin uint32 `protobuf:"varint,2,opt,name=local_admin,json=localAdmin" json:"local_admin,omitempty"` +} + +func (m *RedirectIPv4AddressSpecificExtended) Reset() { *m = RedirectIPv4AddressSpecificExtended{} } +func (m *RedirectIPv4AddressSpecificExtended) String() string { return proto.CompactTextString(m) } +func (*RedirectIPv4AddressSpecificExtended) ProtoMessage() {} +func (*RedirectIPv4AddressSpecificExtended) Descriptor() ([]byte, []int) { + return fileDescriptor1, []int{49} +} + +func (m *RedirectIPv4AddressSpecificExtended) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *RedirectIPv4AddressSpecificExtended) GetLocalAdmin() uint32 { + if m != nil { + return m.LocalAdmin + } + return 0 +} + +type RedirectFourOctetAsSpecificExtended struct { + As uint32 `protobuf:"varint,1,opt,name=as" json:"as,omitempty"` + LocalAdmin uint32 `protobuf:"varint,2,opt,name=local_admin,json=localAdmin" json:"local_admin,omitempty"` +} + +func (m *RedirectFourOctetAsSpecificExtended) Reset() { *m = RedirectFourOctetAsSpecificExtended{} } +func (m *RedirectFourOctetAsSpecificExtended) String() string { return proto.CompactTextString(m) } +func (*RedirectFourOctetAsSpecificExtended) ProtoMessage() {} +func (*RedirectFourOctetAsSpecificExtended) Descriptor() ([]byte, []int) { + return fileDescriptor1, []int{50} +} + +func (m *RedirectFourOctetAsSpecificExtended) GetAs() uint32 { + if m != nil { + return m.As + } + return 0 +} + +func (m *RedirectFourOctetAsSpecificExtended) GetLocalAdmin() uint32 { + if m != nil { + return m.LocalAdmin + } + return 0 +} + +type TrafficRemarkExtended struct { + Dscp uint32 `protobuf:"varint,1,opt,name=dscp" json:"dscp,omitempty"` +} + +func (m *TrafficRemarkExtended) Reset() { *m = TrafficRemarkExtended{} } +func (m *TrafficRemarkExtended) String() string { return proto.CompactTextString(m) } +func (*TrafficRemarkExtended) ProtoMessage() {} +func (*TrafficRemarkExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{51} } + +func (m *TrafficRemarkExtended) GetDscp() uint32 { + if m != nil { + return m.Dscp + } + return 0 +} + +type UnknownExtended struct { + Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *UnknownExtended) Reset() { *m = UnknownExtended{} } +func (m *UnknownExtended) String() string { return proto.CompactTextString(m) } +func (*UnknownExtended) ProtoMessage() {} +func (*UnknownExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{52} } + +func (m *UnknownExtended) GetType() uint32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *UnknownExtended) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +type ExtendedCommunitiesAttribute struct { + // Each Community must be one of: + // - TwoOctetAsSpecificExtended + // - IPv4AddressSpecificExtended + // - FourOctetAsSpecificExtended + // - OpaqueExtended + // - ESILabelExtended + // - MacMobilityExtended + // - RouterMacExtended + // - TrafficRateExtended + // - TrafficActionExtended + // - RedirectTwoOctetAsSpecificExtended + // - RedirectIPv4AddressSpecificExtended + // - RedirectFourOctetAsSpecificExtended + // - TrafficRemarkExtended + // - UnknownExtended + Communities []*google_protobuf.Any `protobuf:"bytes,1,rep,name=communities" json:"communities,omitempty"` +} + +func (m *ExtendedCommunitiesAttribute) Reset() { *m = ExtendedCommunitiesAttribute{} } +func (m *ExtendedCommunitiesAttribute) String() string { return proto.CompactTextString(m) } +func (*ExtendedCommunitiesAttribute) ProtoMessage() {} +func (*ExtendedCommunitiesAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{53} } + +func (m *ExtendedCommunitiesAttribute) GetCommunities() []*google_protobuf.Any { + if m != nil { + return m.Communities + } + return nil +} + +type As4PathAttribute struct { + Segments []*AsSegment `protobuf:"bytes,1,rep,name=segments" json:"segments,omitempty"` +} + +func (m *As4PathAttribute) Reset() { *m = As4PathAttribute{} } +func (m *As4PathAttribute) String() string { return proto.CompactTextString(m) } +func (*As4PathAttribute) ProtoMessage() {} +func (*As4PathAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{54} } + +func (m *As4PathAttribute) GetSegments() []*AsSegment { + if m != nil { + return m.Segments + } + return nil +} + +type As4AggregatorAttribute struct { + As uint32 `protobuf:"varint,2,opt,name=as" json:"as,omitempty"` + Address string `protobuf:"bytes,3,opt,name=address" json:"address,omitempty"` +} + +func (m *As4AggregatorAttribute) Reset() { *m = As4AggregatorAttribute{} } +func (m *As4AggregatorAttribute) String() string { return proto.CompactTextString(m) } +func (*As4AggregatorAttribute) ProtoMessage() {} +func (*As4AggregatorAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{55} } + +func (m *As4AggregatorAttribute) GetAs() uint32 { + if m != nil { + return m.As + } + return 0 +} + +func (m *As4AggregatorAttribute) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +type PmsiTunnelAttribute struct { + Flags uint32 `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"` + Type uint32 `protobuf:"varint,2,opt,name=type" json:"type,omitempty"` + Label uint32 `protobuf:"varint,3,opt,name=label" json:"label,omitempty"` + Id []byte `protobuf:"bytes,4,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *PmsiTunnelAttribute) Reset() { *m = PmsiTunnelAttribute{} } +func (m *PmsiTunnelAttribute) String() string { return proto.CompactTextString(m) } +func (*PmsiTunnelAttribute) ProtoMessage() {} +func (*PmsiTunnelAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{56} } + +func (m *PmsiTunnelAttribute) GetFlags() uint32 { + if m != nil { + return m.Flags + } + return 0 +} + +func (m *PmsiTunnelAttribute) GetType() uint32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *PmsiTunnelAttribute) GetLabel() uint32 { + if m != nil { + return m.Label + } + return 0 +} + +func (m *PmsiTunnelAttribute) GetId() []byte { + if m != nil { + return m.Id + } + return nil +} + +type TunnelEncapSubTLVEncapsulation struct { + Key uint32 `protobuf:"varint,1,opt,name=key" json:"key,omitempty"` + Cookie []byte `protobuf:"bytes,2,opt,name=cookie,proto3" json:"cookie,omitempty"` +} + +func (m *TunnelEncapSubTLVEncapsulation) Reset() { *m = TunnelEncapSubTLVEncapsulation{} } +func (m *TunnelEncapSubTLVEncapsulation) String() string { return proto.CompactTextString(m) } +func (*TunnelEncapSubTLVEncapsulation) ProtoMessage() {} +func (*TunnelEncapSubTLVEncapsulation) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{57} } + +func (m *TunnelEncapSubTLVEncapsulation) GetKey() uint32 { + if m != nil { + return m.Key + } + return 0 +} + +func (m *TunnelEncapSubTLVEncapsulation) GetCookie() []byte { + if m != nil { + return m.Cookie + } + return nil +} + +type TunnelEncapSubTLVProtocol struct { + Protocol uint32 `protobuf:"varint,1,opt,name=protocol" json:"protocol,omitempty"` +} + +func (m *TunnelEncapSubTLVProtocol) Reset() { *m = TunnelEncapSubTLVProtocol{} } +func (m *TunnelEncapSubTLVProtocol) String() string { return proto.CompactTextString(m) } +func (*TunnelEncapSubTLVProtocol) ProtoMessage() {} +func (*TunnelEncapSubTLVProtocol) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{58} } + +func (m *TunnelEncapSubTLVProtocol) GetProtocol() uint32 { + if m != nil { + return m.Protocol + } + return 0 +} + +type TunnelEncapSubTLVColor struct { + Color uint32 `protobuf:"varint,1,opt,name=color" json:"color,omitempty"` +} + +func (m *TunnelEncapSubTLVColor) Reset() { *m = TunnelEncapSubTLVColor{} } +func (m *TunnelEncapSubTLVColor) String() string { return proto.CompactTextString(m) } +func (*TunnelEncapSubTLVColor) ProtoMessage() {} +func (*TunnelEncapSubTLVColor) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{59} } + +func (m *TunnelEncapSubTLVColor) GetColor() uint32 { + if m != nil { + return m.Color + } + return 0 +} + +type TunnelEncapSubTLVUnknown struct { + Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *TunnelEncapSubTLVUnknown) Reset() { *m = TunnelEncapSubTLVUnknown{} } +func (m *TunnelEncapSubTLVUnknown) String() string { return proto.CompactTextString(m) } +func (*TunnelEncapSubTLVUnknown) ProtoMessage() {} +func (*TunnelEncapSubTLVUnknown) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{60} } + +func (m *TunnelEncapSubTLVUnknown) GetType() uint32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *TunnelEncapSubTLVUnknown) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +type TunnelEncapTLV struct { + Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + // Each TLV must be one of: + // - TunnelEncapSubTLVEncapsulation + // - TunnelEncapSubTLVProtocol + // - TunnelEncapSubTLVColor + // - TunnelEncapSubTLVUnknown + Tlvs []*google_protobuf.Any `protobuf:"bytes,2,rep,name=tlvs" json:"tlvs,omitempty"` +} + +func (m *TunnelEncapTLV) Reset() { *m = TunnelEncapTLV{} } +func (m *TunnelEncapTLV) String() string { return proto.CompactTextString(m) } +func (*TunnelEncapTLV) ProtoMessage() {} +func (*TunnelEncapTLV) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{61} } + +func (m *TunnelEncapTLV) GetType() uint32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *TunnelEncapTLV) GetTlvs() []*google_protobuf.Any { + if m != nil { + return m.Tlvs + } + return nil +} + +type TunnelEncapAttribute struct { + Tlvs []*TunnelEncapTLV `protobuf:"bytes,1,rep,name=tlvs" json:"tlvs,omitempty"` +} + +func (m *TunnelEncapAttribute) Reset() { *m = TunnelEncapAttribute{} } +func (m *TunnelEncapAttribute) String() string { return proto.CompactTextString(m) } +func (*TunnelEncapAttribute) ProtoMessage() {} +func (*TunnelEncapAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{62} } + +func (m *TunnelEncapAttribute) GetTlvs() []*TunnelEncapTLV { + if m != nil { + return m.Tlvs + } + return nil +} + +type IPv6AddressSpecificExtended struct { + IsTransitive bool `protobuf:"varint,1,opt,name=is_transitive,json=isTransitive" json:"is_transitive,omitempty"` + SubType uint32 `protobuf:"varint,2,opt,name=sub_type,json=subType" json:"sub_type,omitempty"` + Address string `protobuf:"bytes,3,opt,name=address" json:"address,omitempty"` + LocalAdmin uint32 `protobuf:"varint,4,opt,name=local_admin,json=localAdmin" json:"local_admin,omitempty"` +} + +func (m *IPv6AddressSpecificExtended) Reset() { *m = IPv6AddressSpecificExtended{} } +func (m *IPv6AddressSpecificExtended) String() string { return proto.CompactTextString(m) } +func (*IPv6AddressSpecificExtended) ProtoMessage() {} +func (*IPv6AddressSpecificExtended) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{63} } + +func (m *IPv6AddressSpecificExtended) GetIsTransitive() bool { + if m != nil { + return m.IsTransitive + } + return false +} + +func (m *IPv6AddressSpecificExtended) GetSubType() uint32 { + if m != nil { + return m.SubType + } + return 0 +} + +func (m *IPv6AddressSpecificExtended) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *IPv6AddressSpecificExtended) GetLocalAdmin() uint32 { + if m != nil { + return m.LocalAdmin + } + return 0 +} + +type RedirectIPv6AddressSpecificExtended struct { + Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` + LocalAdmin uint32 `protobuf:"varint,2,opt,name=local_admin,json=localAdmin" json:"local_admin,omitempty"` +} + +func (m *RedirectIPv6AddressSpecificExtended) Reset() { *m = RedirectIPv6AddressSpecificExtended{} } +func (m *RedirectIPv6AddressSpecificExtended) String() string { return proto.CompactTextString(m) } +func (*RedirectIPv6AddressSpecificExtended) ProtoMessage() {} +func (*RedirectIPv6AddressSpecificExtended) Descriptor() ([]byte, []int) { + return fileDescriptor1, []int{64} +} + +func (m *RedirectIPv6AddressSpecificExtended) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *RedirectIPv6AddressSpecificExtended) GetLocalAdmin() uint32 { + if m != nil { + return m.LocalAdmin + } + return 0 +} + +type IP6ExtendedCommunitiesAttribute struct { + // Each Community must be one of: + // - IPv6AddressSpecificExtended + // - RedirectIPv6AddressSpecificExtended + Communities []*google_protobuf.Any `protobuf:"bytes,1,rep,name=communities" json:"communities,omitempty"` +} + +func (m *IP6ExtendedCommunitiesAttribute) Reset() { *m = IP6ExtendedCommunitiesAttribute{} } +func (m *IP6ExtendedCommunitiesAttribute) String() string { return proto.CompactTextString(m) } +func (*IP6ExtendedCommunitiesAttribute) ProtoMessage() {} +func (*IP6ExtendedCommunitiesAttribute) Descriptor() ([]byte, []int) { + return fileDescriptor1, []int{65} +} + +func (m *IP6ExtendedCommunitiesAttribute) GetCommunities() []*google_protobuf.Any { + if m != nil { + return m.Communities + } + return nil +} + +type AigpTLVIGPMetric struct { + Metric uint64 `protobuf:"varint,1,opt,name=metric" json:"metric,omitempty"` +} + +func (m *AigpTLVIGPMetric) Reset() { *m = AigpTLVIGPMetric{} } +func (m *AigpTLVIGPMetric) String() string { return proto.CompactTextString(m) } +func (*AigpTLVIGPMetric) ProtoMessage() {} +func (*AigpTLVIGPMetric) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{66} } + +func (m *AigpTLVIGPMetric) GetMetric() uint64 { + if m != nil { + return m.Metric + } + return 0 +} + +type AigpTLVUnknown struct { + Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *AigpTLVUnknown) Reset() { *m = AigpTLVUnknown{} } +func (m *AigpTLVUnknown) String() string { return proto.CompactTextString(m) } +func (*AigpTLVUnknown) ProtoMessage() {} +func (*AigpTLVUnknown) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{67} } + +func (m *AigpTLVUnknown) GetType() uint32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *AigpTLVUnknown) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +type AigpAttribute struct { + // Each TLV must be one of: + // - AigpTLVIGPMetric + // - AigpTLVUnknown + Tlvs []*google_protobuf.Any `protobuf:"bytes,1,rep,name=tlvs" json:"tlvs,omitempty"` +} + +func (m *AigpAttribute) Reset() { *m = AigpAttribute{} } +func (m *AigpAttribute) String() string { return proto.CompactTextString(m) } +func (*AigpAttribute) ProtoMessage() {} +func (*AigpAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{68} } + +func (m *AigpAttribute) GetTlvs() []*google_protobuf.Any { + if m != nil { + return m.Tlvs + } + return nil +} + +type LargeCommunity struct { + GlobalAdmin uint32 `protobuf:"varint,1,opt,name=global_admin,json=globalAdmin" json:"global_admin,omitempty"` + LocalData1 uint32 `protobuf:"varint,2,opt,name=local_data1,json=localData1" json:"local_data1,omitempty"` + LocalData2 uint32 `protobuf:"varint,3,opt,name=local_data2,json=localData2" json:"local_data2,omitempty"` +} + +func (m *LargeCommunity) Reset() { *m = LargeCommunity{} } +func (m *LargeCommunity) String() string { return proto.CompactTextString(m) } +func (*LargeCommunity) ProtoMessage() {} +func (*LargeCommunity) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{69} } + +func (m *LargeCommunity) GetGlobalAdmin() uint32 { + if m != nil { + return m.GlobalAdmin + } + return 0 +} + +func (m *LargeCommunity) GetLocalData1() uint32 { + if m != nil { + return m.LocalData1 + } + return 0 +} + +func (m *LargeCommunity) GetLocalData2() uint32 { + if m != nil { + return m.LocalData2 + } + return 0 +} + +type LargeCommunitiesAttribute struct { + Communities []*LargeCommunity `protobuf:"bytes,1,rep,name=communities" json:"communities,omitempty"` +} + +func (m *LargeCommunitiesAttribute) Reset() { *m = LargeCommunitiesAttribute{} } +func (m *LargeCommunitiesAttribute) String() string { return proto.CompactTextString(m) } +func (*LargeCommunitiesAttribute) ProtoMessage() {} +func (*LargeCommunitiesAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{70} } + +func (m *LargeCommunitiesAttribute) GetCommunities() []*LargeCommunity { + if m != nil { + return m.Communities + } + return nil +} + +type UnknownAttribute struct { + Flags uint32 `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"` + Type uint32 `protobuf:"varint,2,opt,name=type" json:"type,omitempty"` + Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *UnknownAttribute) Reset() { *m = UnknownAttribute{} } +func (m *UnknownAttribute) String() string { return proto.CompactTextString(m) } +func (*UnknownAttribute) ProtoMessage() {} +func (*UnknownAttribute) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{71} } + +func (m *UnknownAttribute) GetFlags() uint32 { + if m != nil { + return m.Flags + } + return 0 +} + +func (m *UnknownAttribute) GetType() uint32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *UnknownAttribute) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func init() { + proto.RegisterType((*OriginAttribute)(nil), "gobgpapi.OriginAttribute") + proto.RegisterType((*AsSegment)(nil), "gobgpapi.AsSegment") + proto.RegisterType((*AsPathAttribute)(nil), "gobgpapi.AsPathAttribute") + proto.RegisterType((*NextHopAttribute)(nil), "gobgpapi.NextHopAttribute") + proto.RegisterType((*MultiExitDiscAttribute)(nil), "gobgpapi.MultiExitDiscAttribute") + proto.RegisterType((*LocalPrefAttribute)(nil), "gobgpapi.LocalPrefAttribute") + proto.RegisterType((*AtomicAggregateAttribute)(nil), "gobgpapi.AtomicAggregateAttribute") + proto.RegisterType((*AggregatorAttribute)(nil), "gobgpapi.AggregatorAttribute") + proto.RegisterType((*CommunitiesAttribute)(nil), "gobgpapi.CommunitiesAttribute") + proto.RegisterType((*OriginatorIdAttribute)(nil), "gobgpapi.OriginatorIdAttribute") + proto.RegisterType((*ClusterListAttribute)(nil), "gobgpapi.ClusterListAttribute") + proto.RegisterType((*IPAddressPrefix)(nil), "gobgpapi.IPAddressPrefix") + proto.RegisterType((*LabeledIPAddressPrefix)(nil), "gobgpapi.LabeledIPAddressPrefix") + proto.RegisterType((*EncapsulationNLRI)(nil), "gobgpapi.EncapsulationNLRI") + proto.RegisterType((*RouteDistinguisherTwoOctetAS)(nil), "gobgpapi.RouteDistinguisherTwoOctetAS") + proto.RegisterType((*RouteDistinguisherIPAddress)(nil), "gobgpapi.RouteDistinguisherIPAddress") + proto.RegisterType((*RouteDistinguisherFourOctetAS)(nil), "gobgpapi.RouteDistinguisherFourOctetAS") + proto.RegisterType((*EthernetSegmentIdentifier)(nil), "gobgpapi.EthernetSegmentIdentifier") + proto.RegisterType((*EVPNEthernetAutoDiscoveryRoute)(nil), "gobgpapi.EVPNEthernetAutoDiscoveryRoute") + proto.RegisterType((*EVPNMACIPAdvertisementRoute)(nil), "gobgpapi.EVPNMACIPAdvertisementRoute") + proto.RegisterType((*EVPNInclusiveMulticastEthernetTagRoute)(nil), "gobgpapi.EVPNInclusiveMulticastEthernetTagRoute") + proto.RegisterType((*EVPNEthernetSegmentRoute)(nil), "gobgpapi.EVPNEthernetSegmentRoute") + proto.RegisterType((*EVPNIPPrefixRoute)(nil), "gobgpapi.EVPNIPPrefixRoute") + proto.RegisterType((*LabeledVPNIPAddressPrefix)(nil), "gobgpapi.LabeledVPNIPAddressPrefix") + proto.RegisterType((*RouteTargetMembershipNLRI)(nil), "gobgpapi.RouteTargetMembershipNLRI") + proto.RegisterType((*FlowSpecIPPrefix)(nil), "gobgpapi.FlowSpecIPPrefix") + proto.RegisterType((*FlowSpecMAC)(nil), "gobgpapi.FlowSpecMAC") + proto.RegisterType((*FlowSpecComponentItem)(nil), "gobgpapi.FlowSpecComponentItem") + proto.RegisterType((*FlowSpecComponent)(nil), "gobgpapi.FlowSpecComponent") + proto.RegisterType((*FlowSpecNLRI)(nil), "gobgpapi.FlowSpecNLRI") + proto.RegisterType((*VPNFlowSpecNLRI)(nil), "gobgpapi.VPNFlowSpecNLRI") + proto.RegisterType((*OpaqueNLRI)(nil), "gobgpapi.OpaqueNLRI") + proto.RegisterType((*MpReachNLRIAttribute)(nil), "gobgpapi.MpReachNLRIAttribute") + proto.RegisterType((*MpUnreachNLRIAttribute)(nil), "gobgpapi.MpUnreachNLRIAttribute") + proto.RegisterType((*TwoOctetAsSpecificExtended)(nil), "gobgpapi.TwoOctetAsSpecificExtended") + proto.RegisterType((*IPv4AddressSpecificExtended)(nil), "gobgpapi.IPv4AddressSpecificExtended") + proto.RegisterType((*FourOctetAsSpecificExtended)(nil), "gobgpapi.FourOctetAsSpecificExtended") + proto.RegisterType((*ValidationExtended)(nil), "gobgpapi.ValidationExtended") + proto.RegisterType((*ColorExtended)(nil), "gobgpapi.ColorExtended") + proto.RegisterType((*EncapExtended)(nil), "gobgpapi.EncapExtended") + proto.RegisterType((*DefaultGatewayExtended)(nil), "gobgpapi.DefaultGatewayExtended") + proto.RegisterType((*OpaqueExtended)(nil), "gobgpapi.OpaqueExtended") + proto.RegisterType((*ESILabelExtended)(nil), "gobgpapi.ESILabelExtended") + proto.RegisterType((*ESImportRouteTarget)(nil), "gobgpapi.ESImportRouteTarget") + proto.RegisterType((*MacMobilityExtended)(nil), "gobgpapi.MacMobilityExtended") + proto.RegisterType((*RouterMacExtended)(nil), "gobgpapi.RouterMacExtended") + proto.RegisterType((*TrafficRateExtended)(nil), "gobgpapi.TrafficRateExtended") + proto.RegisterType((*TrafficActionExtended)(nil), "gobgpapi.TrafficActionExtended") + proto.RegisterType((*RedirectTwoOctetAsSpecificExtended)(nil), "gobgpapi.RedirectTwoOctetAsSpecificExtended") + proto.RegisterType((*RedirectIPv4AddressSpecificExtended)(nil), "gobgpapi.RedirectIPv4AddressSpecificExtended") + proto.RegisterType((*RedirectFourOctetAsSpecificExtended)(nil), "gobgpapi.RedirectFourOctetAsSpecificExtended") + proto.RegisterType((*TrafficRemarkExtended)(nil), "gobgpapi.TrafficRemarkExtended") + proto.RegisterType((*UnknownExtended)(nil), "gobgpapi.UnknownExtended") + proto.RegisterType((*ExtendedCommunitiesAttribute)(nil), "gobgpapi.ExtendedCommunitiesAttribute") + proto.RegisterType((*As4PathAttribute)(nil), "gobgpapi.As4PathAttribute") + proto.RegisterType((*As4AggregatorAttribute)(nil), "gobgpapi.As4AggregatorAttribute") + proto.RegisterType((*PmsiTunnelAttribute)(nil), "gobgpapi.PmsiTunnelAttribute") + proto.RegisterType((*TunnelEncapSubTLVEncapsulation)(nil), "gobgpapi.TunnelEncapSubTLVEncapsulation") + proto.RegisterType((*TunnelEncapSubTLVProtocol)(nil), "gobgpapi.TunnelEncapSubTLVProtocol") + proto.RegisterType((*TunnelEncapSubTLVColor)(nil), "gobgpapi.TunnelEncapSubTLVColor") + proto.RegisterType((*TunnelEncapSubTLVUnknown)(nil), "gobgpapi.TunnelEncapSubTLVUnknown") + proto.RegisterType((*TunnelEncapTLV)(nil), "gobgpapi.TunnelEncapTLV") + proto.RegisterType((*TunnelEncapAttribute)(nil), "gobgpapi.TunnelEncapAttribute") + proto.RegisterType((*IPv6AddressSpecificExtended)(nil), "gobgpapi.IPv6AddressSpecificExtended") + proto.RegisterType((*RedirectIPv6AddressSpecificExtended)(nil), "gobgpapi.RedirectIPv6AddressSpecificExtended") + proto.RegisterType((*IP6ExtendedCommunitiesAttribute)(nil), "gobgpapi.IP6ExtendedCommunitiesAttribute") + proto.RegisterType((*AigpTLVIGPMetric)(nil), "gobgpapi.AigpTLVIGPMetric") + proto.RegisterType((*AigpTLVUnknown)(nil), "gobgpapi.AigpTLVUnknown") + proto.RegisterType((*AigpAttribute)(nil), "gobgpapi.AigpAttribute") + proto.RegisterType((*LargeCommunity)(nil), "gobgpapi.LargeCommunity") + proto.RegisterType((*LargeCommunitiesAttribute)(nil), "gobgpapi.LargeCommunitiesAttribute") + proto.RegisterType((*UnknownAttribute)(nil), "gobgpapi.UnknownAttribute") +} + +func init() { proto.RegisterFile("attribute.proto", fileDescriptor1) } + +var fileDescriptor1 = []byte{ + // 1868 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xeb, 0x6f, 0x1b, 0xc7, + 0x11, 0x07, 0x8f, 0x94, 0x4c, 0x0e, 0x45, 0x49, 0xa6, 0x64, 0x81, 0x92, 0xe2, 0xc8, 0x5d, 0x37, + 0xad, 0xea, 0x36, 0x72, 0xab, 0x38, 0x6e, 0xed, 0xa0, 0x28, 0x18, 0x49, 0x49, 0xd8, 0x88, 0x32, + 0x73, 0x92, 0x55, 0x14, 0x28, 0xca, 0x2e, 0xef, 0x96, 0xa7, 0x85, 0xee, 0x95, 0xdb, 0x3d, 0x3d, + 0xfe, 0x84, 0x7e, 0x68, 0x91, 0x4f, 0x45, 0xff, 0x92, 0xfe, 0x67, 0xfd, 0x5e, 0xec, 0xeb, 0x1e, + 0xa2, 0xa8, 0x87, 0x53, 0x03, 0xfe, 0xb6, 0xb3, 0x9c, 0x9d, 0x99, 0xfd, 0xed, 0xcc, 0x6f, 0x86, + 0x07, 0x0b, 0x98, 0xf3, 0x84, 0x8e, 0x52, 0x4e, 0xb6, 0xe2, 0x24, 0xe2, 0x51, 0xbb, 0xee, 0x45, + 0x23, 0x2f, 0xc6, 0x31, 0x5d, 0x5b, 0xf5, 0xa2, 0xc8, 0xf3, 0xc9, 0x73, 0xb9, 0x3f, 0x4a, 0xc7, + 0xcf, 0x71, 0x78, 0xa9, 0x94, 0xd0, 0x2f, 0x60, 0xe1, 0x4d, 0x42, 0x3d, 0x1a, 0x76, 0xcd, 0xe9, + 0xf6, 0x0a, 0xcc, 0x46, 0x72, 0xab, 0x53, 0x79, 0x52, 0xd9, 0x6c, 0xd9, 0x5a, 0x42, 0xaf, 0xa0, + 0xd1, 0x65, 0x87, 0xc4, 0x0b, 0x48, 0xc8, 0xdb, 0x6d, 0xa8, 0xf1, 0xcb, 0x98, 0x68, 0x15, 0xb9, + 0x6e, 0x77, 0xe0, 0x41, 0x98, 0x06, 0x23, 0x92, 0xb0, 0x8e, 0xf5, 0xa4, 0xba, 0xd9, 0xb2, 0x8d, + 0x88, 0xbe, 0x84, 0x85, 0x2e, 0x1b, 0x60, 0x7e, 0x92, 0x7b, 0x79, 0x0e, 0x75, 0xa6, 0x6c, 0xb1, + 0x4e, 0xe5, 0x49, 0x75, 0xb3, 0xb9, 0xbd, 0xb4, 0x65, 0x02, 0xde, 0xca, 0xfc, 0xd8, 0x99, 0x12, + 0xfa, 0x14, 0x16, 0x0f, 0xc8, 0x05, 0xff, 0x26, 0x8a, 0x73, 0x23, 0xab, 0x50, 0x0f, 0xc9, 0x05, + 0x1f, 0x9e, 0x44, 0xb1, 0x8c, 0xa4, 0x61, 0x3f, 0x08, 0x95, 0x0e, 0x7a, 0x06, 0x2b, 0xfd, 0xd4, + 0xe7, 0x74, 0xef, 0x82, 0xf2, 0x5d, 0xca, 0x9c, 0xfc, 0xd0, 0x22, 0x54, 0x03, 0xe2, 0xea, 0xc8, + 0xc5, 0x12, 0x7d, 0x06, 0xed, 0xfd, 0xc8, 0xc1, 0xfe, 0x20, 0x21, 0xe3, 0x5c, 0xef, 0x31, 0x80, + 0x2f, 0x76, 0x87, 0x71, 0x42, 0xc6, 0x5a, 0xbd, 0xe1, 0x1b, 0x3d, 0xb4, 0x06, 0x9d, 0x2e, 0x8f, + 0x02, 0xea, 0x74, 0x3d, 0x2f, 0x21, 0x1e, 0xe6, 0x24, 0x3b, 0x8a, 0xfe, 0x00, 0x4b, 0x66, 0x37, + 0x4a, 0x72, 0x8b, 0xf3, 0x60, 0x61, 0x81, 0x8d, 0xb0, 0x64, 0x61, 0x26, 0x00, 0xc3, 0xae, 0x9b, + 0x10, 0xc6, 0x3a, 0x55, 0x15, 0xbd, 0x16, 0xd1, 0xef, 0x60, 0x79, 0x27, 0x0a, 0x82, 0x34, 0xa4, + 0x9c, 0x12, 0x96, 0x5b, 0x78, 0x02, 0x4d, 0x27, 0xdf, 0x97, 0xc0, 0xb5, 0xec, 0xe2, 0x16, 0xfa, + 0x39, 0x3c, 0x52, 0x0f, 0x2a, 0x5c, 0xf7, 0xdc, 0x92, 0x73, 0xea, 0x6a, 0x94, 0x2c, 0xea, 0xa2, + 0x4d, 0x58, 0xde, 0xf1, 0x53, 0xc6, 0x49, 0xb2, 0x4f, 0x19, 0x2f, 0xc1, 0x43, 0x5d, 0x65, 0xba, + 0x61, 0x8b, 0x25, 0xfa, 0x06, 0x16, 0x7a, 0x83, 0xae, 0x8a, 0x4c, 0x5c, 0x9d, 0x5e, 0x08, 0x6c, + 0x62, 0xb9, 0x1a, 0xfa, 0xc4, 0xe4, 0x49, 0x43, 0xed, 0xec, 0x93, 0x50, 0xa4, 0x90, 0x12, 0xe4, + 0x65, 0x1b, 0xb6, 0x96, 0x90, 0x07, 0x2b, 0xfb, 0x78, 0x44, 0x7c, 0xe2, 0x5e, 0x35, 0xb8, 0x02, + 0xb3, 0xbe, 0xf8, 0xc5, 0xdc, 0x49, 0x4b, 0x57, 0x1c, 0x59, 0xd3, 0x1d, 0x55, 0x4b, 0x8e, 0x3e, + 0x85, 0x87, 0x7b, 0xa1, 0x83, 0x63, 0x96, 0xfa, 0x98, 0xd3, 0x28, 0x3c, 0xd8, 0xb7, 0x7b, 0x45, + 0xb8, 0x2b, 0x65, 0xb8, 0x07, 0xf0, 0x91, 0x1d, 0xa5, 0x9c, 0xec, 0x52, 0xc6, 0x69, 0xe8, 0xa5, + 0x94, 0x9d, 0x90, 0xe4, 0xe8, 0x3c, 0x7a, 0xe3, 0x70, 0xc2, 0xbb, 0x87, 0xed, 0x65, 0x98, 0xc1, + 0x6e, 0x90, 0x55, 0x84, 0x12, 0xda, 0x6b, 0x50, 0xc7, 0x8c, 0x51, 0x2f, 0x24, 0xae, 0x8e, 0x2c, + 0x93, 0xd1, 0x1b, 0x58, 0x9f, 0xb4, 0x98, 0x5d, 0xba, 0x6c, 0xb0, 0x71, 0x17, 0x83, 0xdf, 0xc1, + 0xe3, 0x49, 0x83, 0x5f, 0x45, 0x69, 0xf2, 0xee, 0x31, 0xee, 0xc1, 0xea, 0x1e, 0x3f, 0x21, 0x49, + 0x48, 0xb8, 0x2e, 0xb7, 0x9e, 0x4b, 0x42, 0x4e, 0xc7, 0x94, 0x24, 0xd7, 0x16, 0xf8, 0x32, 0xcc, + 0x9c, 0x61, 0x3f, 0x25, 0xd2, 0xd2, 0x9c, 0xad, 0x04, 0xf4, 0x9f, 0x0a, 0x7c, 0xbc, 0x77, 0x3c, + 0x38, 0x30, 0xb6, 0xba, 0x29, 0x8f, 0x44, 0xc5, 0x45, 0x67, 0x24, 0xb9, 0x94, 0x31, 0xb7, 0x7f, + 0x0a, 0x56, 0xa2, 0x72, 0xaf, 0xb9, 0xbd, 0xbc, 0xa5, 0xd8, 0x68, 0xcb, 0xb0, 0xd1, 0x56, 0x37, + 0xbc, 0xb4, 0xad, 0xc4, 0x6d, 0x7f, 0x0e, 0x55, 0xc2, 0xa8, 0x34, 0xde, 0xdc, 0x7e, 0x9a, 0xb3, + 0xc1, 0xd4, 0x20, 0x6d, 0xa1, 0xdf, 0xfe, 0x09, 0xcc, 0x11, 0xad, 0x31, 0xe4, 0xd8, 0x93, 0x99, + 0xd0, 0xb2, 0x9b, 0x66, 0xef, 0x08, 0x7b, 0x22, 0x70, 0x99, 0x4f, 0x9d, 0x9a, 0xc2, 0x46, 0x0a, + 0xe8, 0xbf, 0x15, 0x58, 0x17, 0x81, 0xf7, 0xbb, 0x3b, 0xe2, 0x65, 0xce, 0x48, 0xc2, 0x29, 0x23, + 0x92, 0x76, 0x3e, 0x88, 0xa8, 0x37, 0xa0, 0x19, 0x60, 0x67, 0x68, 0x72, 0xb6, 0x26, 0x53, 0x05, + 0x02, 0xec, 0x98, 0x2c, 0x7a, 0x0c, 0x40, 0xe3, 0xec, 0xf7, 0x19, 0xf9, 0x7b, 0x83, 0xc6, 0xe6, + 0xe7, 0xbc, 0xa6, 0x66, 0x8b, 0x35, 0x85, 0x7e, 0xa8, 0xc0, 0xcf, 0xc4, 0xbd, 0x7b, 0xa1, 0xe3, + 0xa7, 0x8c, 0x9e, 0x11, 0x49, 0x94, 0x0e, 0x66, 0x7c, 0x2f, 0xf7, 0x7e, 0x1f, 0x08, 0xae, 0xde, + 0xc5, 0x9a, 0xbc, 0x4b, 0x39, 0xd4, 0xea, 0x95, 0x50, 0xd1, 0xbf, 0x2a, 0xd0, 0x29, 0xe6, 0x90, + 0xa1, 0xff, 0xf7, 0xff, 0x0e, 0xb7, 0x04, 0xf6, 0x77, 0x0b, 0x1e, 0x4a, 0xac, 0x06, 0x8a, 0xa8, + 0x3e, 0x8c, 0xcc, 0x58, 0x87, 0x06, 0x8d, 0x87, 0x9a, 0xf9, 0x54, 0x5e, 0xd4, 0x69, 0xac, 0xa9, + 0x14, 0x41, 0x2b, 0xfb, 0x51, 0xb2, 0xe6, 0x8c, 0x32, 0x60, 0x14, 0x04, 0x6f, 0x3e, 0x06, 0xf0, + 0xce, 0xb3, 0x5b, 0xcf, 0xaa, 0x5b, 0x7b, 0xe7, 0x05, 0x7a, 0x52, 0xf5, 0xf2, 0xa0, 0x58, 0x2f, + 0x3f, 0x54, 0x60, 0x55, 0xd3, 0xb7, 0x44, 0xe4, 0x6e, 0x0c, 0xae, 0xb0, 0xb2, 0x6e, 0xc1, 0xaa, + 0xcc, 0xf3, 0xd5, 0xe9, 0x3c, 0x5f, 0x2b, 0xf1, 0xfc, 0x77, 0xb0, 0x2a, 0x5f, 0xe4, 0x08, 0x27, + 0x1e, 0xe1, 0x7d, 0x22, 0xc7, 0x8d, 0x13, 0x1a, 0x4b, 0xbe, 0x57, 0xed, 0xb6, 0x92, 0xb5, 0x5b, + 0x11, 0x09, 0xbf, 0x25, 0x12, 0x8e, 0x52, 0x58, 0xfc, 0xca, 0x8f, 0xce, 0x0f, 0x63, 0xe2, 0x98, + 0x47, 0xbf, 0x96, 0x0c, 0xdf, 0xad, 0x33, 0xc9, 0xe9, 0x6a, 0x3c, 0x66, 0x84, 0x6b, 0x2e, 0xd2, + 0x12, 0xfa, 0x02, 0x9a, 0xc6, 0x6d, 0xbf, 0xbb, 0x33, 0x6d, 0xbe, 0x32, 0x2f, 0x66, 0x95, 0xfb, + 0xd7, 0xef, 0xe1, 0x91, 0x39, 0xbc, 0x13, 0x05, 0x71, 0x14, 0x8a, 0xb4, 0xe2, 0x24, 0x10, 0x10, + 0xe8, 0xd1, 0xa8, 0x65, 0x5b, 0x51, 0x5c, 0x66, 0xf0, 0x9a, 0x61, 0xf0, 0xbf, 0xc2, 0xc3, 0x89, + 0xe3, 0xd7, 0x46, 0xf0, 0x39, 0xcc, 0x50, 0x4e, 0x02, 0x35, 0xdf, 0x35, 0xb7, 0x37, 0xf2, 0x9c, + 0xbe, 0xd6, 0xbd, 0xad, 0xb4, 0xd1, 0x6b, 0x98, 0x33, 0xbf, 0xcb, 0x87, 0x79, 0x06, 0x33, 0x49, + 0xea, 0x13, 0x33, 0xf8, 0x5d, 0xff, 0x16, 0x4a, 0x05, 0x39, 0xb0, 0x70, 0x3c, 0x38, 0x28, 0x1d, + 0xbf, 0x5b, 0xf5, 0x65, 0x4e, 0xac, 0xdb, 0x9d, 0xbc, 0x00, 0x78, 0x13, 0xe3, 0xef, 0x53, 0x22, + 0xed, 0x2f, 0x42, 0xf5, 0x94, 0x5c, 0x4a, 0x07, 0x73, 0xb6, 0x58, 0x4e, 0x69, 0x7c, 0xe7, 0xb0, + 0xdc, 0x8f, 0x6d, 0x82, 0x9d, 0x13, 0x71, 0xac, 0x34, 0x40, 0x8f, 0x71, 0x40, 0xfd, 0x4b, 0x33, + 0x40, 0x2b, 0x49, 0x54, 0xad, 0x99, 0x56, 0x55, 0x54, 0x0d, 0xbb, 0xae, 0xc7, 0x55, 0x26, 0xc2, + 0x0d, 0xfd, 0x84, 0x0a, 0x0a, 0xba, 0x21, 0x5c, 0xa9, 0x82, 0xfe, 0x02, 0x2b, 0xfd, 0xf8, 0x6d, + 0x98, 0xdc, 0xdd, 0xf5, 0x7d, 0xac, 0xff, 0xa3, 0x02, 0x6b, 0xd9, 0xec, 0xc3, 0x04, 0xea, 0x74, + 0x4c, 0x9d, 0xbd, 0x0b, 0x4e, 0x42, 0x97, 0xb8, 0xed, 0xa7, 0xd0, 0xa2, 0x6c, 0xc8, 0x13, 0x1c, + 0x32, 0xca, 0xe9, 0x99, 0x4a, 0x90, 0xba, 0x3d, 0x47, 0xd9, 0x51, 0xb6, 0x27, 0x06, 0x73, 0x96, + 0x8e, 0x86, 0x32, 0x81, 0x54, 0x69, 0x3c, 0x60, 0xe9, 0xe8, 0x48, 0xe4, 0x90, 0xaa, 0xca, 0x6a, + 0x56, 0x95, 0x1b, 0xd0, 0x54, 0x63, 0xb6, 0x9a, 0x5e, 0x54, 0x55, 0xa8, 0xc9, 0xbb, 0x2b, 0x76, + 0xd0, 0xbf, 0x2b, 0xb0, 0xde, 0x1b, 0x9c, 0xbd, 0xd0, 0x74, 0xf3, 0x7f, 0x0f, 0x68, 0xea, 0x14, + 0x7e, 0x7b, 0x68, 0xff, 0xac, 0xc0, 0x7a, 0x3e, 0x83, 0x7d, 0x00, 0x58, 0x3d, 0x83, 0xf6, 0x31, + 0xf6, 0xa9, 0x2b, 0x87, 0xde, 0x2c, 0x8c, 0x65, 0x98, 0x61, 0x1c, 0x73, 0x53, 0xcb, 0x4a, 0x40, + 0x9f, 0x40, 0x6b, 0x27, 0xf2, 0xa3, 0xa4, 0xa8, 0xe6, 0x88, 0x0d, 0xa3, 0x26, 0x05, 0xf4, 0x6b, + 0x68, 0xc9, 0x51, 0x3a, 0x53, 0xdb, 0x80, 0x26, 0x4f, 0xc3, 0x90, 0xf8, 0xc3, 0x02, 0x3f, 0x80, + 0xda, 0x12, 0x51, 0xa3, 0x0e, 0xac, 0xec, 0x92, 0x31, 0x4e, 0x7d, 0xfe, 0x35, 0xe6, 0xe4, 0x1c, + 0x5f, 0x9a, 0xa3, 0xe8, 0x5b, 0x98, 0x57, 0x75, 0x76, 0x3f, 0x84, 0xb2, 0xf2, 0xab, 0x16, 0xcb, + 0xcf, 0x86, 0xc5, 0xbd, 0xc3, 0x9e, 0x6c, 0x48, 0x99, 0xb9, 0x4d, 0x58, 0xa4, 0x6c, 0xc8, 0x68, + 0xe8, 0xf9, 0x64, 0x88, 0x9d, 0x82, 0xc5, 0x79, 0xca, 0x0e, 0xe5, 0x76, 0xd7, 0x31, 0x36, 0x55, + 0x8b, 0xb3, 0x8a, 0x2d, 0x6e, 0x1b, 0x96, 0xf6, 0x0e, 0x7b, 0x41, 0x1c, 0x25, 0xbc, 0xd0, 0x57, + 0x44, 0xe5, 0x12, 0x36, 0xa4, 0x72, 0x5f, 0x8f, 0xec, 0x75, 0xc2, 0x94, 0x1e, 0x7a, 0x0b, 0x4b, + 0x7d, 0xec, 0xf4, 0xa3, 0x11, 0xf5, 0x29, 0xcf, 0xee, 0x2a, 0x7b, 0x34, 0x1b, 0x32, 0x4e, 0x9d, + 0xd3, 0x4b, 0x1d, 0x43, 0x9d, 0xb2, 0x43, 0x29, 0x8b, 0x1e, 0xcf, 0xc8, 0xf7, 0x29, 0x09, 0x1d, + 0x32, 0x0c, 0xd3, 0xc0, 0x4c, 0x4c, 0x66, 0xef, 0x20, 0x0d, 0xd0, 0x27, 0xf0, 0x50, 0x86, 0x90, + 0xf4, 0x71, 0x9e, 0x50, 0xe2, 0xbf, 0x2b, 0x76, 0x74, 0x08, 0x62, 0x89, 0x5e, 0xc1, 0xd2, 0x51, + 0x82, 0xc7, 0x63, 0xea, 0xd8, 0x98, 0xe7, 0xb8, 0x5e, 0xed, 0x7d, 0x6d, 0xa8, 0x25, 0x22, 0x03, + 0x84, 0x23, 0xcb, 0x96, 0x6b, 0xf4, 0x2d, 0x3c, 0xd2, 0x47, 0x05, 0x26, 0x85, 0x7c, 0x59, 0x83, + 0x3a, 0x27, 0x49, 0x40, 0x43, 0xec, 0x9b, 0xc8, 0x8d, 0x2c, 0x18, 0x86, 0xe1, 0x20, 0xf6, 0x95, + 0xa9, 0xba, 0xad, 0x25, 0xf4, 0x16, 0x90, 0x4d, 0x5c, 0x9a, 0x10, 0x87, 0xdf, 0x40, 0x1e, 0x57, + 0xc3, 0xba, 0x92, 0xd0, 0xd6, 0x44, 0x42, 0xff, 0x0d, 0x9e, 0x1a, 0xb3, 0x37, 0x71, 0xc0, 0xd4, + 0xbf, 0x76, 0xb7, 0x7b, 0x38, 0xce, 0x3d, 0xdc, 0x54, 0xca, 0xf7, 0x8e, 0xfc, 0x97, 0x19, 0xba, + 0x36, 0x09, 0x70, 0x72, 0x9a, 0x59, 0x6a, 0x43, 0xcd, 0x65, 0x8e, 0xe9, 0xca, 0x72, 0x8d, 0xbe, + 0x80, 0x85, 0xb7, 0xe1, 0x69, 0x18, 0x9d, 0x87, 0x45, 0xb5, 0x3b, 0xfe, 0x01, 0x3b, 0x86, 0x8f, + 0xcc, 0xa9, 0x6b, 0x3f, 0x1a, 0xbc, 0x9c, 0xfc, 0x68, 0x30, 0xad, 0x05, 0x94, 0x3e, 0x25, 0xec, + 0xc0, 0x62, 0x97, 0xbd, 0xf8, 0x91, 0x9f, 0x6d, 0xbe, 0x84, 0x95, 0x2e, 0x7b, 0xf1, 0xe3, 0xbe, + 0x86, 0x10, 0x58, 0x1a, 0x04, 0x8c, 0x1e, 0x49, 0x8a, 0xc9, 0x0d, 0x2c, 0xc3, 0xcc, 0xd8, 0xc7, + 0x9e, 0x79, 0x15, 0x25, 0x64, 0xb8, 0x59, 0x65, 0xdc, 0x54, 0xb1, 0x57, 0x0b, 0xc5, 0xae, 0xbf, + 0x88, 0xd4, 0x24, 0x94, 0x16, 0x75, 0xd1, 0x1f, 0xe1, 0x63, 0xe5, 0x42, 0xf2, 0xdd, 0x61, 0x3a, + 0x3a, 0xda, 0x3f, 0x2e, 0x7d, 0x45, 0x28, 0x4e, 0x06, 0x2d, 0x35, 0x19, 0xac, 0xc0, 0xac, 0x13, + 0x45, 0xa7, 0xd4, 0x3c, 0x89, 0x96, 0xd0, 0x6f, 0x61, 0x75, 0xc2, 0xd6, 0x40, 0x20, 0xed, 0x44, + 0xbe, 0xa8, 0xaf, 0x58, 0xaf, 0xb5, 0xad, 0x4c, 0x46, 0x5b, 0xb0, 0x32, 0x71, 0x50, 0xd2, 0xf4, + 0x14, 0x7a, 0xde, 0x85, 0xce, 0x84, 0xbe, 0x4e, 0xa5, 0x7b, 0xa4, 0xd0, 0x01, 0xcc, 0x17, 0xac, + 0x1c, 0xed, 0x1f, 0x5f, 0x7b, 0x76, 0x13, 0x6a, 0xdc, 0x3f, 0xbb, 0x79, 0xa2, 0x92, 0x1a, 0x68, + 0x17, 0x96, 0x0b, 0xf6, 0xf2, 0x27, 0xfb, 0x95, 0xb6, 0xa0, 0x52, 0xa7, 0x93, 0xa7, 0x4e, 0xd9, + 0xbb, 0xb6, 0xa2, 0x3b, 0xff, 0xcb, 0x0f, 0xb0, 0xf3, 0x97, 0x79, 0xe9, 0xe5, 0x7b, 0xe0, 0xa5, + 0x3f, 0xc3, 0x46, 0x6f, 0xf0, 0xf2, 0xbd, 0x14, 0xf6, 0x33, 0x58, 0xec, 0x52, 0x4f, 0x00, 0xdd, + 0xfb, 0x7a, 0xd0, 0x27, 0x3c, 0xa1, 0x8e, 0x48, 0xe4, 0x40, 0xae, 0x64, 0xa0, 0x35, 0x5b, 0x4b, + 0xe8, 0x35, 0xcc, 0x6b, 0xdd, 0xfb, 0x67, 0xd5, 0x2b, 0x68, 0x89, 0xb3, 0x79, 0xc0, 0x9b, 0xa5, + 0xe7, 0xbf, 0x29, 0x81, 0x52, 0x98, 0xdf, 0x17, 0xbd, 0xd7, 0xdc, 0x5b, 0xb6, 0x4c, 0xcf, 0x8f, + 0x46, 0x19, 0x62, 0xca, 0x7d, 0x53, 0xed, 0x49, 0xc8, 0x72, 0x4c, 0x5d, 0xcc, 0xf1, 0x6f, 0x4a, + 0x98, 0xee, 0x8a, 0x9d, 0xb2, 0xc2, 0xb6, 0x66, 0x83, 0x5c, 0x61, 0x1b, 0xfd, 0x49, 0xfc, 0xc3, + 0x2d, 0xb8, 0x2d, 0xc1, 0xfd, 0xfa, 0x3a, 0xb8, 0x0b, 0x39, 0x5c, 0x0e, 0xb8, 0x0c, 0xb9, 0x0d, + 0x8b, 0x1a, 0xbf, 0x77, 0xe4, 0xaf, 0xc9, 0x01, 0x68, 0x34, 0x2b, 0x71, 0xfb, 0xec, 0x7f, 0x01, + 0x00, 0x00, 0xff, 0xff, 0xf2, 0x23, 0xd6, 0xcf, 0xfa, 0x17, 0x00, 0x00, +} diff --git a/vendor/github.com/osrg/gobgp/api/attribute.proto b/vendor/github.com/osrg/gobgp/api/attribute.proto new file mode 100644 index 00000000..dea22b4f --- /dev/null +++ b/vendor/github.com/osrg/gobgp/api/attribute.proto @@ -0,0 +1,504 @@ +// Copyright (C) 2018 Nippon Telegraph and Telephone Corporation. +// +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation files +// (the "Software"), to deal in the Software without restriction, +// including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, +// and to permit persons to whom the Software is furnished to do so, +// subject to the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. + +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +syntax = "proto3"; + +import "google/protobuf/any.proto"; + +package gobgpapi; + +message OriginAttribute { + uint32 origin = 1; +} + +message AsSegment { + uint32 type = 1; + repeated uint32 numbers = 2; +} + +message AsPathAttribute { + repeated AsSegment segments = 1; +} + +message NextHopAttribute { + string next_hop = 1; +} + +message MultiExitDiscAttribute { + uint32 med = 1; +} + +message LocalPrefAttribute { + uint32 local_pref = 1; +} + +message AtomicAggregateAttribute { +} + +message AggregatorAttribute { + uint32 as = 2; + string address = 3; +} + +message CommunitiesAttribute { + repeated uint32 communities = 1; +} + +message OriginatorIdAttribute { + string id = 1; +} + +message ClusterListAttribute { + repeated string ids = 1; +} + +// IPAddressPrefix represents the NLRI for: +// - AFI=1, SAFI=1 +// - AFI=2, SAFI=1 +message IPAddressPrefix { + uint32 prefix_len = 1; + string prefix = 2; +} + +// LabeledIPAddressPrefix represents the NLRI for: +// - AFI=1, SAFI=4 +// - AFI=2, SAFI=4 +message LabeledIPAddressPrefix { + repeated uint32 labels = 1; + uint32 prefix_len = 2; + string prefix = 3; +} + +// EncapsulationNLRI represents the NLRI for: +// - AFI=1, SAFI=7 +// - AFI=2, SAFI=7 +message EncapsulationNLRI { + string address = 1; +} + +message RouteDistinguisherTwoOctetAS { + uint32 admin = 1; + uint32 assigned = 2; +} + +message RouteDistinguisherIPAddress { + string admin = 1; + uint32 assigned = 2; +} + +message RouteDistinguisherFourOctetAS { + uint32 admin = 1; + uint32 assigned = 2; +} + +message EthernetSegmentIdentifier { + uint32 type = 1; + bytes value = 2; +} + +// EVPNEthernetAutoDiscoveryRoute represents the NLRI for: +// - AFI=25, SAFI=70, RouteType=1 +message EVPNEthernetAutoDiscoveryRoute { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + google.protobuf.Any rd = 1; + EthernetSegmentIdentifier esi = 2; + uint32 ethernet_tag = 3; + uint32 label = 4; +} + +// EVPNMACIPAdvertisementRoute represents the NLRI for: +// - AFI=25, SAFI=70, RouteType=2 +message EVPNMACIPAdvertisementRoute { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + google.protobuf.Any rd = 1; + EthernetSegmentIdentifier esi = 2; + uint32 ethernet_tag = 3; + string mac_address = 4; + string ip_address = 5; + repeated uint32 labels = 6; +} + +// EVPNInclusiveMulticastEthernetTagRoute represents the NLRI for: +// - AFI=25, SAFI=70, RouteType=3 +message EVPNInclusiveMulticastEthernetTagRoute { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + google.protobuf.Any rd = 1; + uint32 ethernet_tag = 2; + string ip_address = 3; +} + +// EVPNEthernetSegmentRoute represents the NLRI for: +// - AFI=25, SAFI=70, RouteType=4 +message EVPNEthernetSegmentRoute { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + google.protobuf.Any rd = 1; + EthernetSegmentIdentifier esi = 2; + string ip_address = 3; +} + +// EVPNIPPrefixRoute represents the NLRI for: +// - AFI=25, SAFI=70, RouteType=5 +message EVPNIPPrefixRoute { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + google.protobuf.Any rd = 1; + EthernetSegmentIdentifier esi = 2; + uint32 ethernet_tag = 3; + string ip_prefix = 4; + uint32 ip_prefix_len = 5; + string gw_address = 6; + uint32 label = 7; +} + +// LabeledVPNIPAddressPrefix represents the NLRI for: +// - AFI=1, SAFI=128 +// - AFI=2, SAFI=128 +message LabeledVPNIPAddressPrefix { + repeated uint32 labels = 1; + // One of: + // - TwoOctetAsSpecificExtended + // - IPv4AddressSpecificExtended + // - FourOctetAsSpecificExtended + google.protobuf.Any rd = 2; + uint32 prefix_len = 3; + string prefix = 4; +} + +// RouteTargetMembershipNLRI represents the NLRI for: +// - AFI=1, SAFI=132 +message RouteTargetMembershipNLRI { + uint32 as = 1; + // One of: + // - TwoOctetAsSpecificExtended + // - IPv4AddressSpecificExtended + // - FourOctetAsSpecificExtended + google.protobuf.Any rt = 2; +} + +message FlowSpecIPPrefix { + uint32 type = 1; + uint32 prefix_len = 2; + string prefix = 3; + // IPv6 only + uint32 offset = 4; +} + +message FlowSpecMAC { + uint32 type = 1; + string address = 2; +} + +message FlowSpecComponentItem { + // Operator for Numeric type, Operand for Bitmask type + uint32 op = 1; + uint64 value = 2; +} + +message FlowSpecComponent { + uint32 type = 1; + repeated FlowSpecComponentItem items = 2; +} + +// FlowSpecNLRI represents the NLRI for: +// - AFI=1, SAFI=133 +// - AFI=2, SAFI=133 +message FlowSpecNLRI { + // One of: + // - FlowSpecIPPrefix + // - FlowSpecMAC + // - FlowSpecComponent + repeated google.protobuf.Any rules = 1; +} + +// VPNFlowSpecNLRI represents the NLRI for: +// - AFI=1, SAFI=134 +// - AFI=2, SAFI=134 +// - AFI=25, SAFI=134 +message VPNFlowSpecNLRI { + // One of: + // - RouteDistinguisherTwoOctetAS + // - RouteDistinguisherIPAddressAS + // - RouteDistinguisherFourOctetAS + google.protobuf.Any rd = 1; + // One of: + // - FlowSpecIPPrefix + // - FlowSpecMAC + // - FlowSpecComponent + repeated google.protobuf.Any rules = 2; +} + +// OpaqueNLRI represents the NLRI for: +// - AFI=16397, SAFI=241 +message OpaqueNLRI { + bytes key = 1; + bytes value = 2; +} + +message MpReachNLRIAttribute { + uint32 family = 1; + repeated string next_hops = 2; + // Each NLRI must be one of: + // - IPAddressPrefix + // - LabeledIPAddressPrefix + // - EncapsulationNLRI + // - EVPNEthernetAutoDiscoveryRoute + // - EVPNMACIPAdvertisementRoute + // - EVPNInclusiveMulticastEthernetTagRoute + // - EVPNEthernetSegmentRoute + // - EVPNIPPrefixRoute + // - LabeledVPNIPAddressPrefix + // - RouteTargetMembershipNLRI + // - FlowSpecNLRI + // - VPNFlowSpecNLRI + // - OpaqueNLRI + repeated google.protobuf.Any nlris = 3; +} + +message MpUnreachNLRIAttribute { + uint32 family = 1; + // The same as NLRI field of MpReachNLRIAttribute + repeated google.protobuf.Any nlris = 3; +} + +message TwoOctetAsSpecificExtended { + bool is_transitive = 1; + uint32 sub_type = 2; + uint32 as = 3; + uint32 local_admin = 4; +} + +message IPv4AddressSpecificExtended { + bool is_transitive = 1; + uint32 sub_type = 2; + string address = 3; + uint32 local_admin = 4; +} + +message FourOctetAsSpecificExtended { + bool is_transitive = 1; + uint32 sub_type = 2; + uint32 as = 3; + uint32 local_admin = 4; +} + +message ValidationExtended { + uint32 state = 1; +} + +message ColorExtended { + uint32 color = 1; +} + +message EncapExtended { + uint32 tunnel_type = 1; +} + +message DefaultGatewayExtended { +} + +message OpaqueExtended { + bool is_transitive = 1; + bytes value = 3; +} + +message ESILabelExtended { + bool is_single_active = 1; + uint32 label = 2; +} + +message ESImportRouteTarget { + string es_import = 1; +} + +message MacMobilityExtended { + bool is_sticky = 1; + uint32 sequence_num = 2; +} + +message RouterMacExtended { + string mac = 1; +} + +message TrafficRateExtended { + uint32 as = 1; + float rate = 2; +} + +message TrafficActionExtended { + bool terminal = 1; + bool sample = 2; +} + +message RedirectTwoOctetAsSpecificExtended { + uint32 as = 1; + uint32 local_admin = 2; +} + +message RedirectIPv4AddressSpecificExtended { + string address = 1; + uint32 local_admin = 2; +} + +message RedirectFourOctetAsSpecificExtended { + uint32 as = 1; + uint32 local_admin = 2; +} + +message TrafficRemarkExtended { + uint32 dscp = 1; +} + +message UnknownExtended { + uint32 type = 1; + bytes value = 2; +} + +message ExtendedCommunitiesAttribute { + // Each Community must be one of: + // - TwoOctetAsSpecificExtended + // - IPv4AddressSpecificExtended + // - FourOctetAsSpecificExtended + // - OpaqueExtended + // - ESILabelExtended + // - MacMobilityExtended + // - RouterMacExtended + // - TrafficRateExtended + // - TrafficActionExtended + // - RedirectTwoOctetAsSpecificExtended + // - RedirectIPv4AddressSpecificExtended + // - RedirectFourOctetAsSpecificExtended + // - TrafficRemarkExtended + // - UnknownExtended + repeated google.protobuf.Any communities = 1; +} + +message As4PathAttribute { + repeated AsSegment segments = 1; +} + +message As4AggregatorAttribute { + uint32 as = 2; + string address = 3; +} + +message PmsiTunnelAttribute { + uint32 flags = 1; + uint32 type = 2; + uint32 label = 3; + bytes id = 4; +} + +message TunnelEncapSubTLVEncapsulation { + uint32 key = 1; + bytes cookie = 2; +} + +message TunnelEncapSubTLVProtocol { + uint32 protocol = 1; +} + +message TunnelEncapSubTLVColor { + uint32 color = 1; +} + +message TunnelEncapSubTLVUnknown { + uint32 type = 1; + bytes value = 2; +} + +message TunnelEncapTLV { + uint32 type = 1; + // Each TLV must be one of: + // - TunnelEncapSubTLVEncapsulation + // - TunnelEncapSubTLVProtocol + // - TunnelEncapSubTLVColor + // - TunnelEncapSubTLVUnknown + repeated google.protobuf.Any tlvs = 2; +} + +message TunnelEncapAttribute { + repeated TunnelEncapTLV tlvs = 1; +} + +message IPv6AddressSpecificExtended { + bool is_transitive = 1; + uint32 sub_type = 2; + string address = 3; + uint32 local_admin = 4; +} + +message RedirectIPv6AddressSpecificExtended { + string address = 1; + uint32 local_admin = 2; +} + +message IP6ExtendedCommunitiesAttribute { + // Each Community must be one of: + // - IPv6AddressSpecificExtended + // - RedirectIPv6AddressSpecificExtended + repeated google.protobuf.Any communities = 1; +} + +message AigpTLVIGPMetric { + uint64 metric = 1; +} + +message AigpTLVUnknown { + uint32 type = 1; + bytes value = 2; +} + +message AigpAttribute { + // Each TLV must be one of: + // - AigpTLVIGPMetric + // - AigpTLVUnknown + repeated google.protobuf.Any tlvs = 1; +} + +message LargeCommunity { + uint32 global_admin = 1; + uint32 local_data1 = 2; + uint32 local_data2 = 3; +} + +message LargeCommunitiesAttribute { + repeated LargeCommunity communities = 1; +} + +message UnknownAttribute { + uint32 flags = 1; + uint32 type = 2; + bytes value = 3; +} diff --git a/vendor/github.com/osrg/gobgp/api/capability.go b/vendor/github.com/osrg/gobgp/api/capability.go new file mode 100644 index 00000000..80e16c6f --- /dev/null +++ b/vendor/github.com/osrg/gobgp/api/capability.go @@ -0,0 +1,288 @@ +// Copyright (C) 2018 Nippon Telegraph and Telephone Corporation. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +// implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package gobgpapi + +import ( + "fmt" + + proto "github.com/golang/protobuf/proto" + "github.com/golang/protobuf/ptypes" + "github.com/golang/protobuf/ptypes/any" + + "github.com/osrg/gobgp/packet/bgp" +) + +func NewMultiProtocolCapability(a *bgp.CapMultiProtocol) *MultiProtocolCapability { + return &MultiProtocolCapability{ + Family: Family(a.CapValue), + } +} + +func (a *MultiProtocolCapability) ToNative() (*bgp.CapMultiProtocol, error) { + return bgp.NewCapMultiProtocol(bgp.RouteFamily(a.Family)), nil +} + +func NewRouteRefreshCapability(a *bgp.CapRouteRefresh) *RouteRefreshCapability { + return &RouteRefreshCapability{} +} + +func (a *RouteRefreshCapability) ToNative() (*bgp.CapRouteRefresh, error) { + return bgp.NewCapRouteRefresh(), nil +} + +func NewCarryingLabelInfoCapability(a *bgp.CapCarryingLabelInfo) *CarryingLabelInfoCapability { + return &CarryingLabelInfoCapability{} +} + +func (a *CarryingLabelInfoCapability) ToNative() (*bgp.CapCarryingLabelInfo, error) { + return bgp.NewCapCarryingLabelInfo(), nil +} + +func NewExtendedNexthopCapability(a *bgp.CapExtendedNexthop) *ExtendedNexthopCapability { + tuples := make([]*ExtendedNexthopCapabilityTuple, 0, len(a.Tuples)) + for _, t := range a.Tuples { + tuples = append(tuples, &ExtendedNexthopCapabilityTuple{ + NlriFamily: Family(bgp.AfiSafiToRouteFamily(t.NLRIAFI, uint8(t.NLRISAFI))), + NexthopFamily: Family(bgp.AfiSafiToRouteFamily(t.NexthopAFI, bgp.SAFI_UNICAST)), + }) + } + return &ExtendedNexthopCapability{ + Tuples: tuples, + } +} + +func (a *ExtendedNexthopCapability) ToNative() (*bgp.CapExtendedNexthop, error) { + tuples := make([]*bgp.CapExtendedNexthopTuple, 0, len(a.Tuples)) + for _, t := range a.Tuples { + var nhAfi uint16 + switch t.NexthopFamily { + case Family_IPv4: + nhAfi = bgp.AFI_IP + case Family_IPv6: + nhAfi = bgp.AFI_IP6 + default: + return nil, fmt.Errorf("invalid address family for nexthop afi in extended nexthop capability: %s", t.NexthopFamily) + } + tuples = append(tuples, bgp.NewCapExtendedNexthopTuple(bgp.RouteFamily(t.NlriFamily), nhAfi)) + } + return bgp.NewCapExtendedNexthop(tuples), nil +} + +func NewGracefulRestartCapability(a *bgp.CapGracefulRestart) *GracefulRestartCapability { + tuples := make([]*GracefulRestartCapabilityTuple, 0, len(a.Tuples)) + for _, t := range a.Tuples { + tuples = append(tuples, &GracefulRestartCapabilityTuple{ + Family: Family(bgp.AfiSafiToRouteFamily(t.AFI, uint8(t.SAFI))), + Flags: uint32(t.Flags), + }) + } + return &GracefulRestartCapability{ + Flags: uint32(a.Flags), + Time: uint32(a.Time), + Tuples: tuples, + } +} + +func (a *GracefulRestartCapability) ToNative() (*bgp.CapGracefulRestart, error) { + tuples := make([]*bgp.CapGracefulRestartTuple, 0, len(a.Tuples)) + for _, t := range a.Tuples { + var forward bool + if t.Flags&0x80 > 0 { + forward = true + } + tuples = append(tuples, bgp.NewCapGracefulRestartTuple(bgp.RouteFamily(t.Family), forward)) + } + var restarting bool + if a.Flags&0x08 > 0 { + restarting = true + } + var notification bool + if a.Flags&0x04 > 0 { + notification = true + } + return bgp.NewCapGracefulRestart(restarting, notification, uint16(a.Time), tuples), nil +} + +func NewFourOctetASNumberCapability(a *bgp.CapFourOctetASNumber) *FourOctetASNumberCapability { + return &FourOctetASNumberCapability{ + As: a.CapValue, + } +} + +func (a *FourOctetASNumberCapability) ToNative() (*bgp.CapFourOctetASNumber, error) { + return bgp.NewCapFourOctetASNumber(a.As), nil +} + +func NewAddPathCapability(a *bgp.CapAddPath) *AddPathCapability { + tuples := make([]*AddPathCapabilityTuple, 0, len(a.Tuples)) + for _, t := range a.Tuples { + tuples = append(tuples, &AddPathCapabilityTuple{ + Family: Family(t.RouteFamily), + Mode: AddPathMode(t.Mode), + }) + } + return &AddPathCapability{ + Tuples: tuples, + } +} + +func (a *AddPathCapability) ToNative() (*bgp.CapAddPath, error) { + tuples := make([]*bgp.CapAddPathTuple, 0, len(a.Tuples)) + for _, t := range a.Tuples { + tuples = append(tuples, bgp.NewCapAddPathTuple(bgp.RouteFamily(t.Family), bgp.BGPAddPathMode(t.Mode))) + } + return bgp.NewCapAddPath(tuples), nil +} + +func NewEnhancedRouteRefreshCapability(a *bgp.CapEnhancedRouteRefresh) *EnhancedRouteRefreshCapability { + return &EnhancedRouteRefreshCapability{} +} + +func (a *EnhancedRouteRefreshCapability) ToNative() (*bgp.CapEnhancedRouteRefresh, error) { + return bgp.NewCapEnhancedRouteRefresh(), nil +} + +func NewLongLivedGracefulRestartCapability(a *bgp.CapLongLivedGracefulRestart) *LongLivedGracefulRestartCapability { + tuples := make([]*LongLivedGracefulRestartCapabilityTuple, 0, len(a.Tuples)) + for _, t := range a.Tuples { + tuples = append(tuples, &LongLivedGracefulRestartCapabilityTuple{ + Family: Family(bgp.AfiSafiToRouteFamily(t.AFI, uint8(t.SAFI))), + Flags: uint32(t.Flags), + Time: t.RestartTime, + }) + } + return &LongLivedGracefulRestartCapability{ + Tuples: tuples, + } +} + +func (a *LongLivedGracefulRestartCapability) ToNative() (*bgp.CapLongLivedGracefulRestart, error) { + tuples := make([]*bgp.CapLongLivedGracefulRestartTuple, 0, len(a.Tuples)) + for _, t := range a.Tuples { + var forward bool + if t.Flags&0x80 > 0 { + forward = true + } + tuples = append(tuples, bgp.NewCapLongLivedGracefulRestartTuple(bgp.RouteFamily(t.Family), forward, t.Time)) + } + return bgp.NewCapLongLivedGracefulRestart(tuples), nil +} + +func NewRouteRefreshCiscoCapability(a *bgp.CapRouteRefreshCisco) *RouteRefreshCiscoCapability { + return &RouteRefreshCiscoCapability{} +} + +func (a *RouteRefreshCiscoCapability) ToNative() (*bgp.CapRouteRefreshCisco, error) { + return bgp.NewCapRouteRefreshCisco(), nil +} + +func NewUnknownCapability(a *bgp.CapUnknown) *UnknownCapability { + return &UnknownCapability{ + Code: uint32(a.CapCode), + Value: a.CapValue, + } +} + +func (a *UnknownCapability) ToNative() (*bgp.CapUnknown, error) { + return bgp.NewCapUnknown(bgp.BGPCapabilityCode(a.Code), a.Value), nil +} + +func MarshalCapability(value bgp.ParameterCapabilityInterface) (*any.Any, error) { + var m proto.Message + switch n := value.(type) { + case *bgp.CapMultiProtocol: + m = NewMultiProtocolCapability(n) + case *bgp.CapRouteRefresh: + m = NewRouteRefreshCapability(n) + case *bgp.CapCarryingLabelInfo: + m = NewCarryingLabelInfoCapability(n) + case *bgp.CapExtendedNexthop: + m = NewExtendedNexthopCapability(n) + case *bgp.CapGracefulRestart: + m = NewGracefulRestartCapability(n) + case *bgp.CapFourOctetASNumber: + m = NewFourOctetASNumberCapability(n) + case *bgp.CapAddPath: + m = NewAddPathCapability(n) + case *bgp.CapEnhancedRouteRefresh: + m = NewEnhancedRouteRefreshCapability(n) + case *bgp.CapLongLivedGracefulRestart: + m = NewLongLivedGracefulRestartCapability(n) + case *bgp.CapRouteRefreshCisco: + m = NewRouteRefreshCiscoCapability(n) + case *bgp.CapUnknown: + m = NewUnknownCapability(n) + default: + return nil, fmt.Errorf("invalid capability type to marshal: %+v", value) + } + return ptypes.MarshalAny(m) +} + +func MarshalCapabilities(values []bgp.ParameterCapabilityInterface) ([]*any.Any, error) { + caps := make([]*any.Any, 0, len(values)) + for _, value := range values { + a, err := MarshalCapability(value) + if err != nil { + return nil, err + } + caps = append(caps, a) + } + return caps, nil +} + +func UnmarshalCapability(a *any.Any) (bgp.ParameterCapabilityInterface, error) { + var value ptypes.DynamicAny + if err := ptypes.UnmarshalAny(a, &value); err != nil { + return nil, fmt.Errorf("failed to unmarshal capability: %s", err) + } + switch v := value.Message.(type) { + case *MultiProtocolCapability: + return v.ToNative() + case *RouteRefreshCapability: + return v.ToNative() + case *CarryingLabelInfoCapability: + return v.ToNative() + case *ExtendedNexthopCapability: + return v.ToNative() + case *GracefulRestartCapability: + return v.ToNative() + case *FourOctetASNumberCapability: + return v.ToNative() + case *AddPathCapability: + return v.ToNative() + case *EnhancedRouteRefreshCapability: + return v.ToNative() + case *LongLivedGracefulRestartCapability: + return v.ToNative() + case *RouteRefreshCiscoCapability: + return v.ToNative() + case *UnknownCapability: + return v.ToNative() + } + return nil, fmt.Errorf("invalid capability type to unmarshal: %s", a.TypeUrl) +} + +func UnmarshalCapabilities(values []*any.Any) ([]bgp.ParameterCapabilityInterface, error) { + caps := make([]bgp.ParameterCapabilityInterface, 0, len(values)) + for _, value := range values { + c, err := UnmarshalCapability(value) + if err != nil { + return nil, err + } + caps = append(caps, c) + } + return caps, nil +} diff --git a/vendor/github.com/osrg/gobgp/api/capability.pb.go b/vendor/github.com/osrg/gobgp/api/capability.pb.go new file mode 100644 index 00000000..9e468509 --- /dev/null +++ b/vendor/github.com/osrg/gobgp/api/capability.pb.go @@ -0,0 +1,379 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: capability.proto + +package gobgpapi + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type AddPathMode int32 + +const ( + AddPathMode_MODE_NONE AddPathMode = 0 + AddPathMode_MODE_RECEIVE AddPathMode = 1 + AddPathMode_MODE_SEND AddPathMode = 2 + AddPathMode_MODE_BOTH AddPathMode = 3 +) + +var AddPathMode_name = map[int32]string{ + 0: "MODE_NONE", + 1: "MODE_RECEIVE", + 2: "MODE_SEND", + 3: "MODE_BOTH", +} +var AddPathMode_value = map[string]int32{ + "MODE_NONE": 0, + "MODE_RECEIVE": 1, + "MODE_SEND": 2, + "MODE_BOTH": 3, +} + +func (x AddPathMode) String() string { + return proto.EnumName(AddPathMode_name, int32(x)) +} +func (AddPathMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } + +type MultiProtocolCapability struct { + Family Family `protobuf:"varint,1,opt,name=family,enum=gobgpapi.Family" json:"family,omitempty"` +} + +func (m *MultiProtocolCapability) Reset() { *m = MultiProtocolCapability{} } +func (m *MultiProtocolCapability) String() string { return proto.CompactTextString(m) } +func (*MultiProtocolCapability) ProtoMessage() {} +func (*MultiProtocolCapability) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } + +func (m *MultiProtocolCapability) GetFamily() Family { + if m != nil { + return m.Family + } + return Family_RESERVED +} + +type RouteRefreshCapability struct { +} + +func (m *RouteRefreshCapability) Reset() { *m = RouteRefreshCapability{} } +func (m *RouteRefreshCapability) String() string { return proto.CompactTextString(m) } +func (*RouteRefreshCapability) ProtoMessage() {} +func (*RouteRefreshCapability) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} } + +type CarryingLabelInfoCapability struct { +} + +func (m *CarryingLabelInfoCapability) Reset() { *m = CarryingLabelInfoCapability{} } +func (m *CarryingLabelInfoCapability) String() string { return proto.CompactTextString(m) } +func (*CarryingLabelInfoCapability) ProtoMessage() {} +func (*CarryingLabelInfoCapability) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} } + +type ExtendedNexthopCapabilityTuple struct { + NlriFamily Family `protobuf:"varint,1,opt,name=nlri_family,json=nlriFamily,enum=gobgpapi.Family" json:"nlri_family,omitempty"` + // Nexthop AFI must be either + // gobgp.IPv4 or + // gobgp.IPv6. + NexthopFamily Family `protobuf:"varint,2,opt,name=nexthop_family,json=nexthopFamily,enum=gobgpapi.Family" json:"nexthop_family,omitempty"` +} + +func (m *ExtendedNexthopCapabilityTuple) Reset() { *m = ExtendedNexthopCapabilityTuple{} } +func (m *ExtendedNexthopCapabilityTuple) String() string { return proto.CompactTextString(m) } +func (*ExtendedNexthopCapabilityTuple) ProtoMessage() {} +func (*ExtendedNexthopCapabilityTuple) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} } + +func (m *ExtendedNexthopCapabilityTuple) GetNlriFamily() Family { + if m != nil { + return m.NlriFamily + } + return Family_RESERVED +} + +func (m *ExtendedNexthopCapabilityTuple) GetNexthopFamily() Family { + if m != nil { + return m.NexthopFamily + } + return Family_RESERVED +} + +type ExtendedNexthopCapability struct { + Tuples []*ExtendedNexthopCapabilityTuple `protobuf:"bytes,1,rep,name=tuples" json:"tuples,omitempty"` +} + +func (m *ExtendedNexthopCapability) Reset() { *m = ExtendedNexthopCapability{} } +func (m *ExtendedNexthopCapability) String() string { return proto.CompactTextString(m) } +func (*ExtendedNexthopCapability) ProtoMessage() {} +func (*ExtendedNexthopCapability) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} } + +func (m *ExtendedNexthopCapability) GetTuples() []*ExtendedNexthopCapabilityTuple { + if m != nil { + return m.Tuples + } + return nil +} + +type GracefulRestartCapabilityTuple struct { + Family Family `protobuf:"varint,1,opt,name=family,enum=gobgpapi.Family" json:"family,omitempty"` + Flags uint32 `protobuf:"varint,2,opt,name=flags" json:"flags,omitempty"` +} + +func (m *GracefulRestartCapabilityTuple) Reset() { *m = GracefulRestartCapabilityTuple{} } +func (m *GracefulRestartCapabilityTuple) String() string { return proto.CompactTextString(m) } +func (*GracefulRestartCapabilityTuple) ProtoMessage() {} +func (*GracefulRestartCapabilityTuple) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} } + +func (m *GracefulRestartCapabilityTuple) GetFamily() Family { + if m != nil { + return m.Family + } + return Family_RESERVED +} + +func (m *GracefulRestartCapabilityTuple) GetFlags() uint32 { + if m != nil { + return m.Flags + } + return 0 +} + +type GracefulRestartCapability struct { + Flags uint32 `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"` + Time uint32 `protobuf:"varint,2,opt,name=time" json:"time,omitempty"` + Tuples []*GracefulRestartCapabilityTuple `protobuf:"bytes,3,rep,name=tuples" json:"tuples,omitempty"` +} + +func (m *GracefulRestartCapability) Reset() { *m = GracefulRestartCapability{} } +func (m *GracefulRestartCapability) String() string { return proto.CompactTextString(m) } +func (*GracefulRestartCapability) ProtoMessage() {} +func (*GracefulRestartCapability) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} } + +func (m *GracefulRestartCapability) GetFlags() uint32 { + if m != nil { + return m.Flags + } + return 0 +} + +func (m *GracefulRestartCapability) GetTime() uint32 { + if m != nil { + return m.Time + } + return 0 +} + +func (m *GracefulRestartCapability) GetTuples() []*GracefulRestartCapabilityTuple { + if m != nil { + return m.Tuples + } + return nil +} + +type FourOctetASNumberCapability struct { + As uint32 `protobuf:"varint,1,opt,name=as" json:"as,omitempty"` +} + +func (m *FourOctetASNumberCapability) Reset() { *m = FourOctetASNumberCapability{} } +func (m *FourOctetASNumberCapability) String() string { return proto.CompactTextString(m) } +func (*FourOctetASNumberCapability) ProtoMessage() {} +func (*FourOctetASNumberCapability) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} } + +func (m *FourOctetASNumberCapability) GetAs() uint32 { + if m != nil { + return m.As + } + return 0 +} + +type AddPathCapabilityTuple struct { + Family Family `protobuf:"varint,1,opt,name=family,enum=gobgpapi.Family" json:"family,omitempty"` + Mode AddPathMode `protobuf:"varint,2,opt,name=mode,enum=gobgpapi.AddPathMode" json:"mode,omitempty"` +} + +func (m *AddPathCapabilityTuple) Reset() { *m = AddPathCapabilityTuple{} } +func (m *AddPathCapabilityTuple) String() string { return proto.CompactTextString(m) } +func (*AddPathCapabilityTuple) ProtoMessage() {} +func (*AddPathCapabilityTuple) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} } + +func (m *AddPathCapabilityTuple) GetFamily() Family { + if m != nil { + return m.Family + } + return Family_RESERVED +} + +func (m *AddPathCapabilityTuple) GetMode() AddPathMode { + if m != nil { + return m.Mode + } + return AddPathMode_MODE_NONE +} + +type AddPathCapability struct { + Tuples []*AddPathCapabilityTuple `protobuf:"bytes,1,rep,name=tuples" json:"tuples,omitempty"` +} + +func (m *AddPathCapability) Reset() { *m = AddPathCapability{} } +func (m *AddPathCapability) String() string { return proto.CompactTextString(m) } +func (*AddPathCapability) ProtoMessage() {} +func (*AddPathCapability) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} } + +func (m *AddPathCapability) GetTuples() []*AddPathCapabilityTuple { + if m != nil { + return m.Tuples + } + return nil +} + +type EnhancedRouteRefreshCapability struct { +} + +func (m *EnhancedRouteRefreshCapability) Reset() { *m = EnhancedRouteRefreshCapability{} } +func (m *EnhancedRouteRefreshCapability) String() string { return proto.CompactTextString(m) } +func (*EnhancedRouteRefreshCapability) ProtoMessage() {} +func (*EnhancedRouteRefreshCapability) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} } + +type LongLivedGracefulRestartCapabilityTuple struct { + Family Family `protobuf:"varint,1,opt,name=family,enum=gobgpapi.Family" json:"family,omitempty"` + Flags uint32 `protobuf:"varint,2,opt,name=flags" json:"flags,omitempty"` + Time uint32 `protobuf:"varint,3,opt,name=time" json:"time,omitempty"` +} + +func (m *LongLivedGracefulRestartCapabilityTuple) Reset() { + *m = LongLivedGracefulRestartCapabilityTuple{} +} +func (m *LongLivedGracefulRestartCapabilityTuple) String() string { return proto.CompactTextString(m) } +func (*LongLivedGracefulRestartCapabilityTuple) ProtoMessage() {} +func (*LongLivedGracefulRestartCapabilityTuple) Descriptor() ([]byte, []int) { + return fileDescriptor2, []int{11} +} + +func (m *LongLivedGracefulRestartCapabilityTuple) GetFamily() Family { + if m != nil { + return m.Family + } + return Family_RESERVED +} + +func (m *LongLivedGracefulRestartCapabilityTuple) GetFlags() uint32 { + if m != nil { + return m.Flags + } + return 0 +} + +func (m *LongLivedGracefulRestartCapabilityTuple) GetTime() uint32 { + if m != nil { + return m.Time + } + return 0 +} + +type LongLivedGracefulRestartCapability struct { + Tuples []*LongLivedGracefulRestartCapabilityTuple `protobuf:"bytes,1,rep,name=tuples" json:"tuples,omitempty"` +} + +func (m *LongLivedGracefulRestartCapability) Reset() { *m = LongLivedGracefulRestartCapability{} } +func (m *LongLivedGracefulRestartCapability) String() string { return proto.CompactTextString(m) } +func (*LongLivedGracefulRestartCapability) ProtoMessage() {} +func (*LongLivedGracefulRestartCapability) Descriptor() ([]byte, []int) { + return fileDescriptor2, []int{12} +} + +func (m *LongLivedGracefulRestartCapability) GetTuples() []*LongLivedGracefulRestartCapabilityTuple { + if m != nil { + return m.Tuples + } + return nil +} + +type RouteRefreshCiscoCapability struct { +} + +func (m *RouteRefreshCiscoCapability) Reset() { *m = RouteRefreshCiscoCapability{} } +func (m *RouteRefreshCiscoCapability) String() string { return proto.CompactTextString(m) } +func (*RouteRefreshCiscoCapability) ProtoMessage() {} +func (*RouteRefreshCiscoCapability) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{13} } + +type UnknownCapability struct { + Code uint32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *UnknownCapability) Reset() { *m = UnknownCapability{} } +func (m *UnknownCapability) String() string { return proto.CompactTextString(m) } +func (*UnknownCapability) ProtoMessage() {} +func (*UnknownCapability) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{14} } + +func (m *UnknownCapability) GetCode() uint32 { + if m != nil { + return m.Code + } + return 0 +} + +func (m *UnknownCapability) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func init() { + proto.RegisterType((*MultiProtocolCapability)(nil), "gobgpapi.MultiProtocolCapability") + proto.RegisterType((*RouteRefreshCapability)(nil), "gobgpapi.RouteRefreshCapability") + proto.RegisterType((*CarryingLabelInfoCapability)(nil), "gobgpapi.CarryingLabelInfoCapability") + proto.RegisterType((*ExtendedNexthopCapabilityTuple)(nil), "gobgpapi.ExtendedNexthopCapabilityTuple") + proto.RegisterType((*ExtendedNexthopCapability)(nil), "gobgpapi.ExtendedNexthopCapability") + proto.RegisterType((*GracefulRestartCapabilityTuple)(nil), "gobgpapi.GracefulRestartCapabilityTuple") + proto.RegisterType((*GracefulRestartCapability)(nil), "gobgpapi.GracefulRestartCapability") + proto.RegisterType((*FourOctetASNumberCapability)(nil), "gobgpapi.FourOctetASNumberCapability") + proto.RegisterType((*AddPathCapabilityTuple)(nil), "gobgpapi.AddPathCapabilityTuple") + proto.RegisterType((*AddPathCapability)(nil), "gobgpapi.AddPathCapability") + proto.RegisterType((*EnhancedRouteRefreshCapability)(nil), "gobgpapi.EnhancedRouteRefreshCapability") + proto.RegisterType((*LongLivedGracefulRestartCapabilityTuple)(nil), "gobgpapi.LongLivedGracefulRestartCapabilityTuple") + proto.RegisterType((*LongLivedGracefulRestartCapability)(nil), "gobgpapi.LongLivedGracefulRestartCapability") + proto.RegisterType((*RouteRefreshCiscoCapability)(nil), "gobgpapi.RouteRefreshCiscoCapability") + proto.RegisterType((*UnknownCapability)(nil), "gobgpapi.UnknownCapability") + proto.RegisterEnum("gobgpapi.AddPathMode", AddPathMode_name, AddPathMode_value) +} + +func init() { proto.RegisterFile("capability.proto", fileDescriptor2) } + +var fileDescriptor2 = []byte{ + // 520 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xcd, 0x6f, 0xd3, 0x4e, + 0x10, 0xfd, 0x39, 0xc9, 0x2f, 0x82, 0x49, 0x13, 0xb9, 0x2b, 0x28, 0x29, 0x51, 0xa3, 0x68, 0x2f, + 0x04, 0x24, 0x22, 0xb5, 0x1c, 0xe0, 0x82, 0x44, 0x49, 0x5d, 0x88, 0x94, 0x8f, 0xca, 0x2d, 0xdc, + 0x50, 0xd9, 0xd8, 0x6b, 0x67, 0xc5, 0x7a, 0xd7, 0xb2, 0xd7, 0xa5, 0x39, 0x70, 0xe6, 0xc2, 0x1f, + 0x8d, 0xfc, 0x11, 0xdb, 0xa4, 0x72, 0x5b, 0x21, 0x71, 0x9b, 0xf1, 0xce, 0xbc, 0x79, 0x6f, 0xde, + 0xae, 0x41, 0xb7, 0x88, 0x4f, 0x96, 0x8c, 0x33, 0xb5, 0x1e, 0xf9, 0x81, 0x54, 0x12, 0x3d, 0x70, + 0xe5, 0xd2, 0xf5, 0x89, 0xcf, 0x9e, 0xb6, 0x92, 0x28, 0xfd, 0x8c, 0xc7, 0xf0, 0x64, 0x16, 0x71, + 0xc5, 0xce, 0xe2, 0xcc, 0x92, 0x7c, 0x9c, 0xf7, 0xa1, 0x21, 0x34, 0x1d, 0xe2, 0x31, 0xbe, 0xee, + 0x6a, 0x03, 0x6d, 0xd8, 0x39, 0xd2, 0x47, 0x1b, 0x88, 0xd1, 0x69, 0xf2, 0xdd, 0xcc, 0xce, 0x71, + 0x17, 0xf6, 0x4c, 0x19, 0x29, 0x6a, 0x52, 0x27, 0xa0, 0xe1, 0xaa, 0xc0, 0xc0, 0x07, 0xd0, 0x1b, + 0x93, 0x20, 0x58, 0x33, 0xe1, 0x4e, 0xc9, 0x92, 0xf2, 0x89, 0x70, 0x64, 0xe9, 0xf8, 0x97, 0x06, + 0x7d, 0xe3, 0x5a, 0x51, 0x61, 0x53, 0x7b, 0x4e, 0xaf, 0xd5, 0x4a, 0xfa, 0xc5, 0xe9, 0x45, 0xe4, + 0x73, 0x8a, 0x0e, 0xa1, 0x25, 0x78, 0xc0, 0x2e, 0xef, 0xa0, 0x02, 0x71, 0x51, 0x1a, 0xa3, 0xd7, + 0xd0, 0x11, 0x29, 0xd8, 0xa6, 0xab, 0x56, 0xd1, 0xd5, 0xce, 0xea, 0xd2, 0x14, 0x7f, 0x81, 0xfd, + 0x4a, 0x36, 0xe8, 0x1d, 0x34, 0x55, 0xcc, 0x28, 0xec, 0x6a, 0x83, 0xfa, 0xb0, 0x75, 0x34, 0x2c, + 0xd0, 0x6e, 0x97, 0x60, 0x66, 0x7d, 0xf8, 0x2b, 0xf4, 0x3f, 0x04, 0xc4, 0xa2, 0x4e, 0xc4, 0x4d, + 0x1a, 0x2a, 0x12, 0xa8, 0x6d, 0xb1, 0xf7, 0x5e, 0x39, 0x7a, 0x04, 0xff, 0x3b, 0x9c, 0xb8, 0x61, + 0x22, 0xad, 0x6d, 0xa6, 0x09, 0xfe, 0xa9, 0xc1, 0x7e, 0xe5, 0x88, 0xa2, 0x47, 0x2b, 0xf5, 0x20, + 0x04, 0x0d, 0xc5, 0x3c, 0x9a, 0x01, 0x25, 0x71, 0x49, 0x6b, 0x7d, 0x5b, 0xeb, 0xed, 0x0a, 0x72, + 0xad, 0x2f, 0xa1, 0x77, 0x2a, 0xa3, 0x60, 0x61, 0x29, 0xaa, 0x8e, 0xcf, 0xe7, 0x91, 0xb7, 0xa4, + 0x41, 0x89, 0x4a, 0x07, 0x6a, 0x64, 0xc3, 0xa3, 0x46, 0x42, 0xec, 0xc1, 0xde, 0xb1, 0x6d, 0x9f, + 0x11, 0xb5, 0xfa, 0xfb, 0x95, 0x3c, 0x87, 0x86, 0x27, 0x6d, 0x9a, 0x99, 0xfd, 0xb8, 0xa8, 0xcb, + 0x90, 0x67, 0xd2, 0xa6, 0x66, 0x52, 0x82, 0x67, 0xb0, 0x7b, 0x63, 0x1c, 0x7a, 0xb3, 0x65, 0xf0, + 0xe0, 0x06, 0x42, 0x95, 0xd8, 0x01, 0xf4, 0x0d, 0xb1, 0x22, 0xc2, 0xa2, 0x76, 0xc5, 0x3b, 0xf8, + 0x01, 0xcf, 0xa6, 0x52, 0xb8, 0x53, 0x76, 0x45, 0xed, 0x7f, 0x7b, 0x07, 0x72, 0x3f, 0xeb, 0x85, + 0x9f, 0x58, 0x02, 0xbe, 0x7b, 0x3c, 0x9a, 0x6c, 0x2d, 0xe0, 0xb0, 0x98, 0x7c, 0x4f, 0xf2, 0xf9, + 0x46, 0x0e, 0xa0, 0xf7, 0xc7, 0x26, 0x58, 0x68, 0x95, 0xdf, 0xfd, 0x5b, 0xd8, 0xfd, 0x24, 0xbe, + 0x09, 0xf9, 0x5d, 0x94, 0xc6, 0x23, 0x68, 0x58, 0xb1, 0x7f, 0xe9, 0xad, 0x48, 0xe2, 0x58, 0xe2, + 0x15, 0xe1, 0x51, 0x6a, 0xea, 0x8e, 0x99, 0x26, 0x2f, 0xa6, 0xd0, 0x2a, 0x79, 0x8a, 0xda, 0xf0, + 0x70, 0xb6, 0x38, 0x31, 0x2e, 0xe7, 0x8b, 0xb9, 0xa1, 0xff, 0x87, 0x74, 0xd8, 0x49, 0x52, 0xd3, + 0x18, 0x1b, 0x93, 0xcf, 0x86, 0xae, 0xe5, 0x05, 0xe7, 0xc6, 0xfc, 0x44, 0xaf, 0xe5, 0xe9, 0xfb, + 0xc5, 0xc5, 0x47, 0xbd, 0xbe, 0x6c, 0x26, 0x7f, 0xc2, 0x57, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, + 0xd6, 0xbd, 0xd3, 0xc3, 0x34, 0x05, 0x00, 0x00, +} diff --git a/vendor/github.com/osrg/gobgp/api/capability.proto b/vendor/github.com/osrg/gobgp/api/capability.proto new file mode 100644 index 00000000..78504b5d --- /dev/null +++ b/vendor/github.com/osrg/gobgp/api/capability.proto @@ -0,0 +1,100 @@ +// Copyright (C) 2018 Nippon Telegraph and Telephone Corporation. +// +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation files +// (the "Software"), to deal in the Software without restriction, +// including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, +// and to permit persons to whom the Software is furnished to do so, +// subject to the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. + +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +syntax = "proto3"; + +import "gobgp.proto"; + +package gobgpapi; + +enum AddPathMode { + MODE_NONE = 0; + MODE_RECEIVE = 1; + MODE_SEND = 2; + MODE_BOTH = 3; +} + +message MultiProtocolCapability { + gobgpapi.Family family = 1; +} + +message RouteRefreshCapability { +} + +message CarryingLabelInfoCapability { +} + +message ExtendedNexthopCapabilityTuple { + gobgpapi.Family nlri_family = 1; + // Nexthop AFI must be either + // gobgp.IPv4 or + // gobgp.IPv6. + gobgpapi.Family nexthop_family = 2; +} + +message ExtendedNexthopCapability { + repeated ExtendedNexthopCapabilityTuple tuples = 1; +} + +message GracefulRestartCapabilityTuple { + gobgpapi.Family family = 1; + uint32 flags = 2; +} + +message GracefulRestartCapability { + uint32 flags = 1; + uint32 time = 2; + repeated GracefulRestartCapabilityTuple tuples = 3; +} + +message FourOctetASNumberCapability { + uint32 as = 1; +} + +message AddPathCapabilityTuple { + gobgpapi.Family family = 1; + AddPathMode mode = 2; +} + +message AddPathCapability { + repeated AddPathCapabilityTuple tuples = 1; +} + +message EnhancedRouteRefreshCapability { +} + +message LongLivedGracefulRestartCapabilityTuple { + gobgpapi.Family family = 1; + uint32 flags = 2; + uint32 time = 3; +} + +message LongLivedGracefulRestartCapability { + repeated LongLivedGracefulRestartCapabilityTuple tuples = 1; +} + +message RouteRefreshCiscoCapability { +} + +message UnknownCapability { + uint32 code = 1; + bytes value = 2; +} \ No newline at end of file diff --git a/vendor/github.com/osrg/gobgp/api/gobgp.pb.go b/vendor/github.com/osrg/gobgp/api/gobgp.pb.go index 63c8efdf..0738c0a0 100644 --- a/vendor/github.com/osrg/gobgp/api/gobgp.pb.go +++ b/vendor/github.com/osrg/gobgp/api/gobgp.pb.go @@ -6,6 +6,8 @@ Package gobgpapi is a generated protocol buffer package. It is generated from these files: gobgp.proto + attribute.proto + capability.proto It has these top-level messages: GetNeighborRequest @@ -19,6 +21,16 @@ It has these top-level messages: AddNeighborResponse DeleteNeighborRequest DeleteNeighborResponse + UpdateNeighborRequest + UpdateNeighborResponse + AddPeerGroupRequest + AddPeerGroupResponse + DeletePeerGroupRequest + DeletePeerGroupResponse + UpdatePeerGroupRequest + UpdatePeerGroupResponse + AddDynamicNeighborRequest + AddDynamicNeighborResponse ResetNeighborRequest ResetNeighborResponse SoftResetNeighborRequest @@ -29,6 +41,8 @@ It has these top-level messages: EnableNeighborResponse DisableNeighborRequest DisableNeighborResponse + UpdatePolicyRequest + UpdatePolicyResponse EnableMrtRequest EnableMrtResponse DisableMrtRequest @@ -114,9 +128,13 @@ It has these top-level messages: ValidateRibRequest ValidateRibResponse Peer + PeerGroup + DynamicNeighbor ApplyPolicy PrefixLimit PeerConf + PeerGroupConf + PeerGroupState EbgpMultihop RouteReflector PeerState @@ -170,20 +188,115 @@ It has these top-level messages: Statement Policy PolicyAssignment + RoutingPolicy Roa GetRoaRequest GetRoaResponse Vrf + DefaultRouteDistance Global + Confederation TableInfo GetRibInfoRequest GetRibInfoResponse + AddCollectorRequest + AddCollectorResponse + ShutdownRequest + ShutdownResponse + OriginAttribute + AsSegment + AsPathAttribute + NextHopAttribute + MultiExitDiscAttribute + LocalPrefAttribute + AtomicAggregateAttribute + AggregatorAttribute + CommunitiesAttribute + OriginatorIdAttribute + ClusterListAttribute + IPAddressPrefix + LabeledIPAddressPrefix + EncapsulationNLRI + RouteDistinguisherTwoOctetAS + RouteDistinguisherIPAddress + RouteDistinguisherFourOctetAS + EthernetSegmentIdentifier + EVPNEthernetAutoDiscoveryRoute + EVPNMACIPAdvertisementRoute + EVPNInclusiveMulticastEthernetTagRoute + EVPNEthernetSegmentRoute + EVPNIPPrefixRoute + LabeledVPNIPAddressPrefix + RouteTargetMembershipNLRI + FlowSpecIPPrefix + FlowSpecMAC + FlowSpecComponentItem + FlowSpecComponent + FlowSpecNLRI + VPNFlowSpecNLRI + OpaqueNLRI + MpReachNLRIAttribute + MpUnreachNLRIAttribute + TwoOctetAsSpecificExtended + IPv4AddressSpecificExtended + FourOctetAsSpecificExtended + ValidationExtended + ColorExtended + EncapExtended + DefaultGatewayExtended + OpaqueExtended + ESILabelExtended + ESImportRouteTarget + MacMobilityExtended + RouterMacExtended + TrafficRateExtended + TrafficActionExtended + RedirectTwoOctetAsSpecificExtended + RedirectIPv4AddressSpecificExtended + RedirectFourOctetAsSpecificExtended + TrafficRemarkExtended + UnknownExtended + ExtendedCommunitiesAttribute + As4PathAttribute + As4AggregatorAttribute + PmsiTunnelAttribute + TunnelEncapSubTLVEncapsulation + TunnelEncapSubTLVProtocol + TunnelEncapSubTLVColor + TunnelEncapSubTLVUnknown + TunnelEncapTLV + TunnelEncapAttribute + IPv6AddressSpecificExtended + RedirectIPv6AddressSpecificExtended + IP6ExtendedCommunitiesAttribute + AigpTLVIGPMetric + AigpTLVUnknown + AigpAttribute + LargeCommunity + LargeCommunitiesAttribute + UnknownAttribute + MultiProtocolCapability + RouteRefreshCapability + CarryingLabelInfoCapability + ExtendedNexthopCapabilityTuple + ExtendedNexthopCapability + GracefulRestartCapabilityTuple + GracefulRestartCapability + FourOctetASNumberCapability + AddPathCapabilityTuple + AddPathCapability + EnhancedRouteRefreshCapability + LongLivedGracefulRestartCapabilityTuple + LongLivedGracefulRestartCapability + RouteRefreshCiscoCapability + UnknownCapability */ package gobgpapi import proto "github.com/golang/protobuf/proto" import fmt "fmt" import math "math" +import google_protobuf "github.com/golang/protobuf/ptypes/any" import ( context "golang.org/x/net/context" @@ -205,7 +318,7 @@ const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package type Family int32 const ( - Family__ Family = 0 + Family_RESERVED Family = 0 Family_IPv4 Family = 65537 Family_IPv6 Family = 131073 Family_IPv4_MC Family = 65538 @@ -230,7 +343,7 @@ const ( ) var Family_name = map[int32]string{ - 0: "_", + 0: "RESERVED", 65537: "IPv4", 131073: "IPv6", 65538: "IPv4_MC", @@ -254,7 +367,7 @@ var Family_name = map[int32]string{ 1074594033: "OPAQUE", } var Family_value = map[string]int32{ - "_": 0, + "RESERVED": 0, "IPv4": 65537, "IPv6": 131073, "IPv4_MC": 65538, @@ -348,6 +461,7 @@ const ( DefinedType_COMMUNITY DefinedType = 4 DefinedType_EXT_COMMUNITY DefinedType = 5 DefinedType_LARGE_COMMUNITY DefinedType = 6 + DefinedType_NEXT_HOP DefinedType = 7 ) var DefinedType_name = map[int32]string{ @@ -358,6 +472,7 @@ var DefinedType_name = map[int32]string{ 4: "COMMUNITY", 5: "EXT_COMMUNITY", 6: "LARGE_COMMUNITY", + 7: "NEXT_HOP", } var DefinedType_value = map[string]int32{ "PREFIX": 0, @@ -367,6 +482,7 @@ var DefinedType_value = map[string]int32{ "COMMUNITY": 4, "EXT_COMMUNITY": 5, "LARGE_COMMUNITY": 6, + "NEXT_HOP": 7, } func (x DefinedType) String() string { @@ -538,7 +654,7 @@ func (x SoftResetNeighborRequest_SoftResetDirection) String() string { return proto.EnumName(SoftResetNeighborRequest_SoftResetDirection_name, int32(x)) } func (SoftResetNeighborRequest_SoftResetDirection) EnumDescriptor() ([]byte, []int) { - return fileDescriptor0, []int{13, 0} + return fileDescriptor0, []int{23, 0} } type AddBmpRequest_MonitoringPolicy int32 @@ -570,7 +686,7 @@ func (x AddBmpRequest_MonitoringPolicy) String() string { return proto.EnumName(AddBmpRequest_MonitoringPolicy_name, int32(x)) } func (AddBmpRequest_MonitoringPolicy) EnumDescriptor() ([]byte, []int) { - return fileDescriptor0, []int{27, 0} + return fileDescriptor0, []int{39, 0} } type RPKIValidation_State int32 @@ -598,7 +714,7 @@ var RPKIValidation_State_value = map[string]int32{ func (x RPKIValidation_State) String() string { return proto.EnumName(RPKIValidation_State_name, int32(x)) } -func (RPKIValidation_State) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{95, 0} } +func (RPKIValidation_State) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{107, 0} } type RPKIValidation_Reason int32 @@ -622,7 +738,7 @@ var RPKIValidation_Reason_value = map[string]int32{ func (x RPKIValidation_Reason) String() string { return proto.EnumName(RPKIValidation_Reason_name, int32(x)) } -func (RPKIValidation_Reason) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{95, 1} } +func (RPKIValidation_Reason) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{107, 1} } type PeerConf_RemovePrivateAs int32 @@ -647,7 +763,59 @@ func (x PeerConf_RemovePrivateAs) String() string { return proto.EnumName(PeerConf_RemovePrivateAs_name, int32(x)) } func (PeerConf_RemovePrivateAs) EnumDescriptor() ([]byte, []int) { - return fileDescriptor0, []int{108, 0} + return fileDescriptor0, []int{122, 0} +} + +type PeerGroupConf_RemovePrivateAs int32 + +const ( + PeerGroupConf_NONE PeerGroupConf_RemovePrivateAs = 0 + PeerGroupConf_ALL PeerGroupConf_RemovePrivateAs = 1 + PeerGroupConf_REPLACE PeerGroupConf_RemovePrivateAs = 2 +) + +var PeerGroupConf_RemovePrivateAs_name = map[int32]string{ + 0: "NONE", + 1: "ALL", + 2: "REPLACE", +} +var PeerGroupConf_RemovePrivateAs_value = map[string]int32{ + "NONE": 0, + "ALL": 1, + "REPLACE": 2, +} + +func (x PeerGroupConf_RemovePrivateAs) String() string { + return proto.EnumName(PeerGroupConf_RemovePrivateAs_name, int32(x)) +} +func (PeerGroupConf_RemovePrivateAs) EnumDescriptor() ([]byte, []int) { + return fileDescriptor0, []int{123, 0} +} + +type PeerGroupState_RemovePrivateAs int32 + +const ( + PeerGroupState_NONE PeerGroupState_RemovePrivateAs = 0 + PeerGroupState_ALL PeerGroupState_RemovePrivateAs = 1 + PeerGroupState_REPLACE PeerGroupState_RemovePrivateAs = 2 +) + +var PeerGroupState_RemovePrivateAs_name = map[int32]string{ + 0: "NONE", + 1: "ALL", + 2: "REPLACE", +} +var PeerGroupState_RemovePrivateAs_value = map[string]int32{ + "NONE": 0, + "ALL": 1, + "REPLACE": 2, +} + +func (x PeerGroupState_RemovePrivateAs) String() string { + return proto.EnumName(PeerGroupState_RemovePrivateAs_name, int32(x)) +} +func (PeerGroupState_RemovePrivateAs) EnumDescriptor() ([]byte, []int) { + return fileDescriptor0, []int{124, 0} } type PeerState_AdminState int32 @@ -672,7 +840,7 @@ var PeerState_AdminState_value = map[string]int32{ func (x PeerState_AdminState) String() string { return proto.EnumName(PeerState_AdminState_name, int32(x)) } -func (PeerState_AdminState) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{111, 0} } +func (PeerState_AdminState) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{127, 0} } type Conditions_RouteType int32 @@ -699,7 +867,7 @@ var Conditions_RouteType_value = map[string]int32{ func (x Conditions_RouteType) String() string { return proto.EnumName(Conditions_RouteType_name, int32(x)) } -func (Conditions_RouteType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{152, 0} } +func (Conditions_RouteType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{168, 0} } type GetNeighborRequest struct { EnableAdvertised bool `protobuf:"varint,1,opt,name=enableAdvertised" json:"enableAdvertised,omitempty"` @@ -933,6 +1101,163 @@ func (m *DeleteNeighborResponse) String() string { return proto.Compa func (*DeleteNeighborResponse) ProtoMessage() {} func (*DeleteNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } +type UpdateNeighborRequest struct { + Peer *Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"` + // Calls SoftResetIn after updating the neighbor configuration if needed. + DoSoftResetIn bool `protobuf:"varint,2,opt,name=do_soft_reset_in,json=doSoftResetIn" json:"do_soft_reset_in,omitempty"` +} + +func (m *UpdateNeighborRequest) Reset() { *m = UpdateNeighborRequest{} } +func (m *UpdateNeighborRequest) String() string { return proto.CompactTextString(m) } +func (*UpdateNeighborRequest) ProtoMessage() {} +func (*UpdateNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } + +func (m *UpdateNeighborRequest) GetPeer() *Peer { + if m != nil { + return m.Peer + } + return nil +} + +func (m *UpdateNeighborRequest) GetDoSoftResetIn() bool { + if m != nil { + return m.DoSoftResetIn + } + return false +} + +type UpdateNeighborResponse struct { + // Indicates whether calling SoftResetIn is required due to this update. If + // "true" is set, the client should call SoftResetIn manually. If + // "do_soft_reset_in = true" is set in the request, always returned with + // "false". + NeedsSoftResetIn bool `protobuf:"varint,1,opt,name=needs_soft_reset_in,json=needsSoftResetIn" json:"needs_soft_reset_in,omitempty"` +} + +func (m *UpdateNeighborResponse) Reset() { *m = UpdateNeighborResponse{} } +func (m *UpdateNeighborResponse) String() string { return proto.CompactTextString(m) } +func (*UpdateNeighborResponse) ProtoMessage() {} +func (*UpdateNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } + +func (m *UpdateNeighborResponse) GetNeedsSoftResetIn() bool { + if m != nil { + return m.NeedsSoftResetIn + } + return false +} + +type AddPeerGroupRequest struct { + PeerGroup *PeerGroup `protobuf:"bytes,1,opt,name=peer_group,json=peerGroup" json:"peer_group,omitempty"` +} + +func (m *AddPeerGroupRequest) Reset() { *m = AddPeerGroupRequest{} } +func (m *AddPeerGroupRequest) String() string { return proto.CompactTextString(m) } +func (*AddPeerGroupRequest) ProtoMessage() {} +func (*AddPeerGroupRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } + +func (m *AddPeerGroupRequest) GetPeerGroup() *PeerGroup { + if m != nil { + return m.PeerGroup + } + return nil +} + +type AddPeerGroupResponse struct { +} + +func (m *AddPeerGroupResponse) Reset() { *m = AddPeerGroupResponse{} } +func (m *AddPeerGroupResponse) String() string { return proto.CompactTextString(m) } +func (*AddPeerGroupResponse) ProtoMessage() {} +func (*AddPeerGroupResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } + +type DeletePeerGroupRequest struct { + PeerGroup *PeerGroup `protobuf:"bytes,1,opt,name=peer_group,json=peerGroup" json:"peer_group,omitempty"` +} + +func (m *DeletePeerGroupRequest) Reset() { *m = DeletePeerGroupRequest{} } +func (m *DeletePeerGroupRequest) String() string { return proto.CompactTextString(m) } +func (*DeletePeerGroupRequest) ProtoMessage() {} +func (*DeletePeerGroupRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } + +func (m *DeletePeerGroupRequest) GetPeerGroup() *PeerGroup { + if m != nil { + return m.PeerGroup + } + return nil +} + +type DeletePeerGroupResponse struct { +} + +func (m *DeletePeerGroupResponse) Reset() { *m = DeletePeerGroupResponse{} } +func (m *DeletePeerGroupResponse) String() string { return proto.CompactTextString(m) } +func (*DeletePeerGroupResponse) ProtoMessage() {} +func (*DeletePeerGroupResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } + +type UpdatePeerGroupRequest struct { + PeerGroup *PeerGroup `protobuf:"bytes,1,opt,name=peer_group,json=peerGroup" json:"peer_group,omitempty"` + DoSoftResetIn bool `protobuf:"varint,2,opt,name=do_soft_reset_in,json=doSoftResetIn" json:"do_soft_reset_in,omitempty"` +} + +func (m *UpdatePeerGroupRequest) Reset() { *m = UpdatePeerGroupRequest{} } +func (m *UpdatePeerGroupRequest) String() string { return proto.CompactTextString(m) } +func (*UpdatePeerGroupRequest) ProtoMessage() {} +func (*UpdatePeerGroupRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } + +func (m *UpdatePeerGroupRequest) GetPeerGroup() *PeerGroup { + if m != nil { + return m.PeerGroup + } + return nil +} + +func (m *UpdatePeerGroupRequest) GetDoSoftResetIn() bool { + if m != nil { + return m.DoSoftResetIn + } + return false +} + +type UpdatePeerGroupResponse struct { + NeedsSoftResetIn bool `protobuf:"varint,1,opt,name=needs_soft_reset_in,json=needsSoftResetIn" json:"needs_soft_reset_in,omitempty"` +} + +func (m *UpdatePeerGroupResponse) Reset() { *m = UpdatePeerGroupResponse{} } +func (m *UpdatePeerGroupResponse) String() string { return proto.CompactTextString(m) } +func (*UpdatePeerGroupResponse) ProtoMessage() {} +func (*UpdatePeerGroupResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } + +func (m *UpdatePeerGroupResponse) GetNeedsSoftResetIn() bool { + if m != nil { + return m.NeedsSoftResetIn + } + return false +} + +type AddDynamicNeighborRequest struct { + DynamicNeighbor *DynamicNeighbor `protobuf:"bytes,1,opt,name=dynamic_neighbor,json=dynamicNeighbor" json:"dynamic_neighbor,omitempty"` +} + +func (m *AddDynamicNeighborRequest) Reset() { *m = AddDynamicNeighborRequest{} } +func (m *AddDynamicNeighborRequest) String() string { return proto.CompactTextString(m) } +func (*AddDynamicNeighborRequest) ProtoMessage() {} +func (*AddDynamicNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } + +func (m *AddDynamicNeighborRequest) GetDynamicNeighbor() *DynamicNeighbor { + if m != nil { + return m.DynamicNeighbor + } + return nil +} + +type AddDynamicNeighborResponse struct { +} + +func (m *AddDynamicNeighborResponse) Reset() { *m = AddDynamicNeighborResponse{} } +func (m *AddDynamicNeighborResponse) String() string { return proto.CompactTextString(m) } +func (*AddDynamicNeighborResponse) ProtoMessage() {} +func (*AddDynamicNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } + type ResetNeighborRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` Communication string `protobuf:"bytes,2,opt,name=communication" json:"communication,omitempty"` @@ -941,7 +1266,7 @@ type ResetNeighborRequest struct { func (m *ResetNeighborRequest) Reset() { *m = ResetNeighborRequest{} } func (m *ResetNeighborRequest) String() string { return proto.CompactTextString(m) } func (*ResetNeighborRequest) ProtoMessage() {} -func (*ResetNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } +func (*ResetNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } func (m *ResetNeighborRequest) GetAddress() string { if m != nil { @@ -963,7 +1288,7 @@ type ResetNeighborResponse struct { func (m *ResetNeighborResponse) Reset() { *m = ResetNeighborResponse{} } func (m *ResetNeighborResponse) String() string { return proto.CompactTextString(m) } func (*ResetNeighborResponse) ProtoMessage() {} -func (*ResetNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } +func (*ResetNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } type SoftResetNeighborRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` @@ -973,7 +1298,7 @@ type SoftResetNeighborRequest struct { func (m *SoftResetNeighborRequest) Reset() { *m = SoftResetNeighborRequest{} } func (m *SoftResetNeighborRequest) String() string { return proto.CompactTextString(m) } func (*SoftResetNeighborRequest) ProtoMessage() {} -func (*SoftResetNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } +func (*SoftResetNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } func (m *SoftResetNeighborRequest) GetAddress() string { if m != nil { @@ -995,7 +1320,7 @@ type SoftResetNeighborResponse struct { func (m *SoftResetNeighborResponse) Reset() { *m = SoftResetNeighborResponse{} } func (m *SoftResetNeighborResponse) String() string { return proto.CompactTextString(m) } func (*SoftResetNeighborResponse) ProtoMessage() {} -func (*SoftResetNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } +func (*SoftResetNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } type ShutdownNeighborRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` @@ -1005,7 +1330,7 @@ type ShutdownNeighborRequest struct { func (m *ShutdownNeighborRequest) Reset() { *m = ShutdownNeighborRequest{} } func (m *ShutdownNeighborRequest) String() string { return proto.CompactTextString(m) } func (*ShutdownNeighborRequest) ProtoMessage() {} -func (*ShutdownNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } +func (*ShutdownNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} } func (m *ShutdownNeighborRequest) GetAddress() string { if m != nil { @@ -1027,7 +1352,7 @@ type ShutdownNeighborResponse struct { func (m *ShutdownNeighborResponse) Reset() { *m = ShutdownNeighborResponse{} } func (m *ShutdownNeighborResponse) String() string { return proto.CompactTextString(m) } func (*ShutdownNeighborResponse) ProtoMessage() {} -func (*ShutdownNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } +func (*ShutdownNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} } type EnableNeighborRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` @@ -1036,7 +1361,7 @@ type EnableNeighborRequest struct { func (m *EnableNeighborRequest) Reset() { *m = EnableNeighborRequest{} } func (m *EnableNeighborRequest) String() string { return proto.CompactTextString(m) } func (*EnableNeighborRequest) ProtoMessage() {} -func (*EnableNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } +func (*EnableNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} } func (m *EnableNeighborRequest) GetAddress() string { if m != nil { @@ -1051,7 +1376,7 @@ type EnableNeighborResponse struct { func (m *EnableNeighborResponse) Reset() { *m = EnableNeighborResponse{} } func (m *EnableNeighborResponse) String() string { return proto.CompactTextString(m) } func (*EnableNeighborResponse) ProtoMessage() {} -func (*EnableNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } +func (*EnableNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} } type DisableNeighborRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` @@ -1061,7 +1386,7 @@ type DisableNeighborRequest struct { func (m *DisableNeighborRequest) Reset() { *m = DisableNeighborRequest{} } func (m *DisableNeighborRequest) String() string { return proto.CompactTextString(m) } func (*DisableNeighborRequest) ProtoMessage() {} -func (*DisableNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } +func (*DisableNeighborRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} } func (m *DisableNeighborRequest) GetAddress() string { if m != nil { @@ -1083,7 +1408,39 @@ type DisableNeighborResponse struct { func (m *DisableNeighborResponse) Reset() { *m = DisableNeighborResponse{} } func (m *DisableNeighborResponse) String() string { return proto.CompactTextString(m) } func (*DisableNeighborResponse) ProtoMessage() {} -func (*DisableNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } +func (*DisableNeighborResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} } + +type UpdatePolicyRequest struct { + Sets []*DefinedSet `protobuf:"bytes,1,rep,name=sets" json:"sets,omitempty"` + Policies []*Policy `protobuf:"bytes,2,rep,name=policies" json:"policies,omitempty"` +} + +func (m *UpdatePolicyRequest) Reset() { *m = UpdatePolicyRequest{} } +func (m *UpdatePolicyRequest) String() string { return proto.CompactTextString(m) } +func (*UpdatePolicyRequest) ProtoMessage() {} +func (*UpdatePolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} } + +func (m *UpdatePolicyRequest) GetSets() []*DefinedSet { + if m != nil { + return m.Sets + } + return nil +} + +func (m *UpdatePolicyRequest) GetPolicies() []*Policy { + if m != nil { + return m.Policies + } + return nil +} + +type UpdatePolicyResponse struct { +} + +func (m *UpdatePolicyResponse) Reset() { *m = UpdatePolicyResponse{} } +func (m *UpdatePolicyResponse) String() string { return proto.CompactTextString(m) } +func (*UpdatePolicyResponse) ProtoMessage() {} +func (*UpdatePolicyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} } type EnableMrtRequest struct { DumpType int32 `protobuf:"varint,1,opt,name=dump_type,json=dumpType" json:"dump_type,omitempty"` @@ -1094,7 +1451,7 @@ type EnableMrtRequest struct { func (m *EnableMrtRequest) Reset() { *m = EnableMrtRequest{} } func (m *EnableMrtRequest) String() string { return proto.CompactTextString(m) } func (*EnableMrtRequest) ProtoMessage() {} -func (*EnableMrtRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } +func (*EnableMrtRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} } func (m *EnableMrtRequest) GetDumpType() int32 { if m != nil { @@ -1123,7 +1480,7 @@ type EnableMrtResponse struct { func (m *EnableMrtResponse) Reset() { *m = EnableMrtResponse{} } func (m *EnableMrtResponse) String() string { return proto.CompactTextString(m) } func (*EnableMrtResponse) ProtoMessage() {} -func (*EnableMrtResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } +func (*EnableMrtResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} } type DisableMrtRequest struct { } @@ -1131,7 +1488,7 @@ type DisableMrtRequest struct { func (m *DisableMrtRequest) Reset() { *m = DisableMrtRequest{} } func (m *DisableMrtRequest) String() string { return proto.CompactTextString(m) } func (*DisableMrtRequest) ProtoMessage() {} -func (*DisableMrtRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } +func (*DisableMrtRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{35} } type DisableMrtResponse struct { } @@ -1139,7 +1496,7 @@ type DisableMrtResponse struct { func (m *DisableMrtResponse) Reset() { *m = DisableMrtResponse{} } func (m *DisableMrtResponse) String() string { return proto.CompactTextString(m) } func (*DisableMrtResponse) ProtoMessage() {} -func (*DisableMrtResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } +func (*DisableMrtResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{36} } type InjectMrtRequest struct { Resource Resource `protobuf:"varint,1,opt,name=resource,enum=gobgpapi.Resource" json:"resource,omitempty"` @@ -1150,7 +1507,7 @@ type InjectMrtRequest struct { func (m *InjectMrtRequest) Reset() { *m = InjectMrtRequest{} } func (m *InjectMrtRequest) String() string { return proto.CompactTextString(m) } func (*InjectMrtRequest) ProtoMessage() {} -func (*InjectMrtRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} } +func (*InjectMrtRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{37} } func (m *InjectMrtRequest) GetResource() Resource { if m != nil { @@ -1179,7 +1536,7 @@ type InjectMrtResponse struct { func (m *InjectMrtResponse) Reset() { *m = InjectMrtResponse{} } func (m *InjectMrtResponse) String() string { return proto.CompactTextString(m) } func (*InjectMrtResponse) ProtoMessage() {} -func (*InjectMrtResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} } +func (*InjectMrtResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{38} } type AddBmpRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` @@ -1190,7 +1547,7 @@ type AddBmpRequest struct { func (m *AddBmpRequest) Reset() { *m = AddBmpRequest{} } func (m *AddBmpRequest) String() string { return proto.CompactTextString(m) } func (*AddBmpRequest) ProtoMessage() {} -func (*AddBmpRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} } +func (*AddBmpRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{39} } func (m *AddBmpRequest) GetAddress() string { if m != nil { @@ -1219,7 +1576,7 @@ type AddBmpResponse struct { func (m *AddBmpResponse) Reset() { *m = AddBmpResponse{} } func (m *AddBmpResponse) String() string { return proto.CompactTextString(m) } func (*AddBmpResponse) ProtoMessage() {} -func (*AddBmpResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} } +func (*AddBmpResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{40} } type DeleteBmpRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` @@ -1229,7 +1586,7 @@ type DeleteBmpRequest struct { func (m *DeleteBmpRequest) Reset() { *m = DeleteBmpRequest{} } func (m *DeleteBmpRequest) String() string { return proto.CompactTextString(m) } func (*DeleteBmpRequest) ProtoMessage() {} -func (*DeleteBmpRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} } +func (*DeleteBmpRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{41} } func (m *DeleteBmpRequest) GetAddress() string { if m != nil { @@ -1251,7 +1608,7 @@ type DeleteBmpResponse struct { func (m *DeleteBmpResponse) Reset() { *m = DeleteBmpResponse{} } func (m *DeleteBmpResponse) String() string { return proto.CompactTextString(m) } func (*DeleteBmpResponse) ProtoMessage() {} -func (*DeleteBmpResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} } +func (*DeleteBmpResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{42} } type MonitorRibRequest struct { Table *Table `protobuf:"bytes,1,opt,name=table" json:"table,omitempty"` @@ -1261,7 +1618,7 @@ type MonitorRibRequest struct { func (m *MonitorRibRequest) Reset() { *m = MonitorRibRequest{} } func (m *MonitorRibRequest) String() string { return proto.CompactTextString(m) } func (*MonitorRibRequest) ProtoMessage() {} -func (*MonitorRibRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} } +func (*MonitorRibRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{43} } func (m *MonitorRibRequest) GetTable() *Table { if m != nil { @@ -1285,7 +1642,7 @@ type RPKIConf struct { func (m *RPKIConf) Reset() { *m = RPKIConf{} } func (m *RPKIConf) String() string { return proto.CompactTextString(m) } func (*RPKIConf) ProtoMessage() {} -func (*RPKIConf) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} } +func (*RPKIConf) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{44} } func (m *RPKIConf) GetAddress() string { if m != nil { @@ -1324,7 +1681,7 @@ type RPKIState struct { func (m *RPKIState) Reset() { *m = RPKIState{} } func (m *RPKIState) String() string { return proto.CompactTextString(m) } func (*RPKIState) ProtoMessage() {} -func (*RPKIState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} } +func (*RPKIState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{45} } func (m *RPKIState) GetUptime() int64 { if m != nil { @@ -1453,7 +1810,7 @@ type Rpki struct { func (m *Rpki) Reset() { *m = Rpki{} } func (m *Rpki) String() string { return proto.CompactTextString(m) } func (*Rpki) ProtoMessage() {} -func (*Rpki) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} } +func (*Rpki) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{46} } func (m *Rpki) GetConf() *RPKIConf { if m != nil { @@ -1476,7 +1833,7 @@ type GetRpkiRequest struct { func (m *GetRpkiRequest) Reset() { *m = GetRpkiRequest{} } func (m *GetRpkiRequest) String() string { return proto.CompactTextString(m) } func (*GetRpkiRequest) ProtoMessage() {} -func (*GetRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{35} } +func (*GetRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{47} } func (m *GetRpkiRequest) GetFamily() uint32 { if m != nil { @@ -1492,7 +1849,7 @@ type GetRpkiResponse struct { func (m *GetRpkiResponse) Reset() { *m = GetRpkiResponse{} } func (m *GetRpkiResponse) String() string { return proto.CompactTextString(m) } func (*GetRpkiResponse) ProtoMessage() {} -func (*GetRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{36} } +func (*GetRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{48} } func (m *GetRpkiResponse) GetServers() []*Rpki { if m != nil { @@ -1510,7 +1867,7 @@ type AddRpkiRequest struct { func (m *AddRpkiRequest) Reset() { *m = AddRpkiRequest{} } func (m *AddRpkiRequest) String() string { return proto.CompactTextString(m) } func (*AddRpkiRequest) ProtoMessage() {} -func (*AddRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{37} } +func (*AddRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{49} } func (m *AddRpkiRequest) GetAddress() string { if m != nil { @@ -1539,7 +1896,7 @@ type AddRpkiResponse struct { func (m *AddRpkiResponse) Reset() { *m = AddRpkiResponse{} } func (m *AddRpkiResponse) String() string { return proto.CompactTextString(m) } func (*AddRpkiResponse) ProtoMessage() {} -func (*AddRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{38} } +func (*AddRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{50} } type DeleteRpkiRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` @@ -1549,7 +1906,7 @@ type DeleteRpkiRequest struct { func (m *DeleteRpkiRequest) Reset() { *m = DeleteRpkiRequest{} } func (m *DeleteRpkiRequest) String() string { return proto.CompactTextString(m) } func (*DeleteRpkiRequest) ProtoMessage() {} -func (*DeleteRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{39} } +func (*DeleteRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{51} } func (m *DeleteRpkiRequest) GetAddress() string { if m != nil { @@ -1571,7 +1928,7 @@ type DeleteRpkiResponse struct { func (m *DeleteRpkiResponse) Reset() { *m = DeleteRpkiResponse{} } func (m *DeleteRpkiResponse) String() string { return proto.CompactTextString(m) } func (*DeleteRpkiResponse) ProtoMessage() {} -func (*DeleteRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{40} } +func (*DeleteRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{52} } type EnableRpkiRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` @@ -1580,7 +1937,7 @@ type EnableRpkiRequest struct { func (m *EnableRpkiRequest) Reset() { *m = EnableRpkiRequest{} } func (m *EnableRpkiRequest) String() string { return proto.CompactTextString(m) } func (*EnableRpkiRequest) ProtoMessage() {} -func (*EnableRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{41} } +func (*EnableRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{53} } func (m *EnableRpkiRequest) GetAddress() string { if m != nil { @@ -1595,7 +1952,7 @@ type EnableRpkiResponse struct { func (m *EnableRpkiResponse) Reset() { *m = EnableRpkiResponse{} } func (m *EnableRpkiResponse) String() string { return proto.CompactTextString(m) } func (*EnableRpkiResponse) ProtoMessage() {} -func (*EnableRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{42} } +func (*EnableRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{54} } type DisableRpkiRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` @@ -1604,7 +1961,7 @@ type DisableRpkiRequest struct { func (m *DisableRpkiRequest) Reset() { *m = DisableRpkiRequest{} } func (m *DisableRpkiRequest) String() string { return proto.CompactTextString(m) } func (*DisableRpkiRequest) ProtoMessage() {} -func (*DisableRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{43} } +func (*DisableRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{55} } func (m *DisableRpkiRequest) GetAddress() string { if m != nil { @@ -1619,7 +1976,7 @@ type DisableRpkiResponse struct { func (m *DisableRpkiResponse) Reset() { *m = DisableRpkiResponse{} } func (m *DisableRpkiResponse) String() string { return proto.CompactTextString(m) } func (*DisableRpkiResponse) ProtoMessage() {} -func (*DisableRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{44} } +func (*DisableRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{56} } type ResetRpkiRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` @@ -1628,7 +1985,7 @@ type ResetRpkiRequest struct { func (m *ResetRpkiRequest) Reset() { *m = ResetRpkiRequest{} } func (m *ResetRpkiRequest) String() string { return proto.CompactTextString(m) } func (*ResetRpkiRequest) ProtoMessage() {} -func (*ResetRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{45} } +func (*ResetRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{57} } func (m *ResetRpkiRequest) GetAddress() string { if m != nil { @@ -1643,7 +2000,7 @@ type ResetRpkiResponse struct { func (m *ResetRpkiResponse) Reset() { *m = ResetRpkiResponse{} } func (m *ResetRpkiResponse) String() string { return proto.CompactTextString(m) } func (*ResetRpkiResponse) ProtoMessage() {} -func (*ResetRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{46} } +func (*ResetRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{58} } type SoftResetRpkiRequest struct { Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` @@ -1652,7 +2009,7 @@ type SoftResetRpkiRequest struct { func (m *SoftResetRpkiRequest) Reset() { *m = SoftResetRpkiRequest{} } func (m *SoftResetRpkiRequest) String() string { return proto.CompactTextString(m) } func (*SoftResetRpkiRequest) ProtoMessage() {} -func (*SoftResetRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{47} } +func (*SoftResetRpkiRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{59} } func (m *SoftResetRpkiRequest) GetAddress() string { if m != nil { @@ -1667,7 +2024,7 @@ type SoftResetRpkiResponse struct { func (m *SoftResetRpkiResponse) Reset() { *m = SoftResetRpkiResponse{} } func (m *SoftResetRpkiResponse) String() string { return proto.CompactTextString(m) } func (*SoftResetRpkiResponse) ProtoMessage() {} -func (*SoftResetRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{48} } +func (*SoftResetRpkiResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{60} } type EnableZebraRequest struct { Url string `protobuf:"bytes,1,opt,name=url" json:"url,omitempty"` @@ -1680,7 +2037,7 @@ type EnableZebraRequest struct { func (m *EnableZebraRequest) Reset() { *m = EnableZebraRequest{} } func (m *EnableZebraRequest) String() string { return proto.CompactTextString(m) } func (*EnableZebraRequest) ProtoMessage() {} -func (*EnableZebraRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{49} } +func (*EnableZebraRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{61} } func (m *EnableZebraRequest) GetUrl() string { if m != nil { @@ -1723,7 +2080,7 @@ type EnableZebraResponse struct { func (m *EnableZebraResponse) Reset() { *m = EnableZebraResponse{} } func (m *EnableZebraResponse) String() string { return proto.CompactTextString(m) } func (*EnableZebraResponse) ProtoMessage() {} -func (*EnableZebraResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{50} } +func (*EnableZebraResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{62} } type GetVrfRequest struct { } @@ -1731,7 +2088,7 @@ type GetVrfRequest struct { func (m *GetVrfRequest) Reset() { *m = GetVrfRequest{} } func (m *GetVrfRequest) String() string { return proto.CompactTextString(m) } func (*GetVrfRequest) ProtoMessage() {} -func (*GetVrfRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{51} } +func (*GetVrfRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{63} } type GetVrfResponse struct { Vrfs []*Vrf `protobuf:"bytes,1,rep,name=vrfs" json:"vrfs,omitempty"` @@ -1740,7 +2097,7 @@ type GetVrfResponse struct { func (m *GetVrfResponse) Reset() { *m = GetVrfResponse{} } func (m *GetVrfResponse) String() string { return proto.CompactTextString(m) } func (*GetVrfResponse) ProtoMessage() {} -func (*GetVrfResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{52} } +func (*GetVrfResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{64} } func (m *GetVrfResponse) GetVrfs() []*Vrf { if m != nil { @@ -1756,7 +2113,7 @@ type AddVrfRequest struct { func (m *AddVrfRequest) Reset() { *m = AddVrfRequest{} } func (m *AddVrfRequest) String() string { return proto.CompactTextString(m) } func (*AddVrfRequest) ProtoMessage() {} -func (*AddVrfRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{53} } +func (*AddVrfRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{65} } func (m *AddVrfRequest) GetVrf() *Vrf { if m != nil { @@ -1771,7 +2128,7 @@ type AddVrfResponse struct { func (m *AddVrfResponse) Reset() { *m = AddVrfResponse{} } func (m *AddVrfResponse) String() string { return proto.CompactTextString(m) } func (*AddVrfResponse) ProtoMessage() {} -func (*AddVrfResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{54} } +func (*AddVrfResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{66} } type DeleteVrfRequest struct { Vrf *Vrf `protobuf:"bytes,1,opt,name=vrf" json:"vrf,omitempty"` @@ -1780,7 +2137,7 @@ type DeleteVrfRequest struct { func (m *DeleteVrfRequest) Reset() { *m = DeleteVrfRequest{} } func (m *DeleteVrfRequest) String() string { return proto.CompactTextString(m) } func (*DeleteVrfRequest) ProtoMessage() {} -func (*DeleteVrfRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{55} } +func (*DeleteVrfRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{67} } func (m *DeleteVrfRequest) GetVrf() *Vrf { if m != nil { @@ -1795,7 +2152,7 @@ type DeleteVrfResponse struct { func (m *DeleteVrfResponse) Reset() { *m = DeleteVrfResponse{} } func (m *DeleteVrfResponse) String() string { return proto.CompactTextString(m) } func (*DeleteVrfResponse) ProtoMessage() {} -func (*DeleteVrfResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{56} } +func (*DeleteVrfResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{68} } type GetDefinedSetRequest struct { Type DefinedType `protobuf:"varint,1,opt,name=type,enum=gobgpapi.DefinedType" json:"type,omitempty"` @@ -1805,7 +2162,7 @@ type GetDefinedSetRequest struct { func (m *GetDefinedSetRequest) Reset() { *m = GetDefinedSetRequest{} } func (m *GetDefinedSetRequest) String() string { return proto.CompactTextString(m) } func (*GetDefinedSetRequest) ProtoMessage() {} -func (*GetDefinedSetRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{57} } +func (*GetDefinedSetRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{69} } func (m *GetDefinedSetRequest) GetType() DefinedType { if m != nil { @@ -1828,7 +2185,7 @@ type GetDefinedSetResponse struct { func (m *GetDefinedSetResponse) Reset() { *m = GetDefinedSetResponse{} } func (m *GetDefinedSetResponse) String() string { return proto.CompactTextString(m) } func (*GetDefinedSetResponse) ProtoMessage() {} -func (*GetDefinedSetResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{58} } +func (*GetDefinedSetResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{70} } func (m *GetDefinedSetResponse) GetSets() []*DefinedSet { if m != nil { @@ -1844,7 +2201,7 @@ type AddDefinedSetRequest struct { func (m *AddDefinedSetRequest) Reset() { *m = AddDefinedSetRequest{} } func (m *AddDefinedSetRequest) String() string { return proto.CompactTextString(m) } func (*AddDefinedSetRequest) ProtoMessage() {} -func (*AddDefinedSetRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{59} } +func (*AddDefinedSetRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{71} } func (m *AddDefinedSetRequest) GetSet() *DefinedSet { if m != nil { @@ -1859,7 +2216,7 @@ type AddDefinedSetResponse struct { func (m *AddDefinedSetResponse) Reset() { *m = AddDefinedSetResponse{} } func (m *AddDefinedSetResponse) String() string { return proto.CompactTextString(m) } func (*AddDefinedSetResponse) ProtoMessage() {} -func (*AddDefinedSetResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{60} } +func (*AddDefinedSetResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{72} } type DeleteDefinedSetRequest struct { Set *DefinedSet `protobuf:"bytes,1,opt,name=set" json:"set,omitempty"` @@ -1869,7 +2226,7 @@ type DeleteDefinedSetRequest struct { func (m *DeleteDefinedSetRequest) Reset() { *m = DeleteDefinedSetRequest{} } func (m *DeleteDefinedSetRequest) String() string { return proto.CompactTextString(m) } func (*DeleteDefinedSetRequest) ProtoMessage() {} -func (*DeleteDefinedSetRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{61} } +func (*DeleteDefinedSetRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{73} } func (m *DeleteDefinedSetRequest) GetSet() *DefinedSet { if m != nil { @@ -1891,7 +2248,7 @@ type DeleteDefinedSetResponse struct { func (m *DeleteDefinedSetResponse) Reset() { *m = DeleteDefinedSetResponse{} } func (m *DeleteDefinedSetResponse) String() string { return proto.CompactTextString(m) } func (*DeleteDefinedSetResponse) ProtoMessage() {} -func (*DeleteDefinedSetResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{62} } +func (*DeleteDefinedSetResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{74} } type ReplaceDefinedSetRequest struct { Set *DefinedSet `protobuf:"bytes,1,opt,name=set" json:"set,omitempty"` @@ -1900,7 +2257,7 @@ type ReplaceDefinedSetRequest struct { func (m *ReplaceDefinedSetRequest) Reset() { *m = ReplaceDefinedSetRequest{} } func (m *ReplaceDefinedSetRequest) String() string { return proto.CompactTextString(m) } func (*ReplaceDefinedSetRequest) ProtoMessage() {} -func (*ReplaceDefinedSetRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{63} } +func (*ReplaceDefinedSetRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{75} } func (m *ReplaceDefinedSetRequest) GetSet() *DefinedSet { if m != nil { @@ -1915,7 +2272,7 @@ type ReplaceDefinedSetResponse struct { func (m *ReplaceDefinedSetResponse) Reset() { *m = ReplaceDefinedSetResponse{} } func (m *ReplaceDefinedSetResponse) String() string { return proto.CompactTextString(m) } func (*ReplaceDefinedSetResponse) ProtoMessage() {} -func (*ReplaceDefinedSetResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{64} } +func (*ReplaceDefinedSetResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{76} } type GetStatementRequest struct { } @@ -1923,7 +2280,7 @@ type GetStatementRequest struct { func (m *GetStatementRequest) Reset() { *m = GetStatementRequest{} } func (m *GetStatementRequest) String() string { return proto.CompactTextString(m) } func (*GetStatementRequest) ProtoMessage() {} -func (*GetStatementRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{65} } +func (*GetStatementRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{77} } type GetStatementResponse struct { Statements []*Statement `protobuf:"bytes,1,rep,name=statements" json:"statements,omitempty"` @@ -1932,7 +2289,7 @@ type GetStatementResponse struct { func (m *GetStatementResponse) Reset() { *m = GetStatementResponse{} } func (m *GetStatementResponse) String() string { return proto.CompactTextString(m) } func (*GetStatementResponse) ProtoMessage() {} -func (*GetStatementResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{66} } +func (*GetStatementResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{78} } func (m *GetStatementResponse) GetStatements() []*Statement { if m != nil { @@ -1948,7 +2305,7 @@ type AddStatementRequest struct { func (m *AddStatementRequest) Reset() { *m = AddStatementRequest{} } func (m *AddStatementRequest) String() string { return proto.CompactTextString(m) } func (*AddStatementRequest) ProtoMessage() {} -func (*AddStatementRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{67} } +func (*AddStatementRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{79} } func (m *AddStatementRequest) GetStatement() *Statement { if m != nil { @@ -1963,7 +2320,7 @@ type AddStatementResponse struct { func (m *AddStatementResponse) Reset() { *m = AddStatementResponse{} } func (m *AddStatementResponse) String() string { return proto.CompactTextString(m) } func (*AddStatementResponse) ProtoMessage() {} -func (*AddStatementResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{68} } +func (*AddStatementResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{80} } type DeleteStatementRequest struct { Statement *Statement `protobuf:"bytes,1,opt,name=statement" json:"statement,omitempty"` @@ -1973,7 +2330,7 @@ type DeleteStatementRequest struct { func (m *DeleteStatementRequest) Reset() { *m = DeleteStatementRequest{} } func (m *DeleteStatementRequest) String() string { return proto.CompactTextString(m) } func (*DeleteStatementRequest) ProtoMessage() {} -func (*DeleteStatementRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{69} } +func (*DeleteStatementRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{81} } func (m *DeleteStatementRequest) GetStatement() *Statement { if m != nil { @@ -1995,7 +2352,7 @@ type DeleteStatementResponse struct { func (m *DeleteStatementResponse) Reset() { *m = DeleteStatementResponse{} } func (m *DeleteStatementResponse) String() string { return proto.CompactTextString(m) } func (*DeleteStatementResponse) ProtoMessage() {} -func (*DeleteStatementResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{70} } +func (*DeleteStatementResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{82} } type ReplaceStatementRequest struct { Statement *Statement `protobuf:"bytes,1,opt,name=statement" json:"statement,omitempty"` @@ -2004,7 +2361,7 @@ type ReplaceStatementRequest struct { func (m *ReplaceStatementRequest) Reset() { *m = ReplaceStatementRequest{} } func (m *ReplaceStatementRequest) String() string { return proto.CompactTextString(m) } func (*ReplaceStatementRequest) ProtoMessage() {} -func (*ReplaceStatementRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{71} } +func (*ReplaceStatementRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{83} } func (m *ReplaceStatementRequest) GetStatement() *Statement { if m != nil { @@ -2019,7 +2376,7 @@ type ReplaceStatementResponse struct { func (m *ReplaceStatementResponse) Reset() { *m = ReplaceStatementResponse{} } func (m *ReplaceStatementResponse) String() string { return proto.CompactTextString(m) } func (*ReplaceStatementResponse) ProtoMessage() {} -func (*ReplaceStatementResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{72} } +func (*ReplaceStatementResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{84} } type GetPolicyRequest struct { } @@ -2027,7 +2384,7 @@ type GetPolicyRequest struct { func (m *GetPolicyRequest) Reset() { *m = GetPolicyRequest{} } func (m *GetPolicyRequest) String() string { return proto.CompactTextString(m) } func (*GetPolicyRequest) ProtoMessage() {} -func (*GetPolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{73} } +func (*GetPolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{85} } type GetPolicyResponse struct { Policies []*Policy `protobuf:"bytes,1,rep,name=policies" json:"policies,omitempty"` @@ -2036,7 +2393,7 @@ type GetPolicyResponse struct { func (m *GetPolicyResponse) Reset() { *m = GetPolicyResponse{} } func (m *GetPolicyResponse) String() string { return proto.CompactTextString(m) } func (*GetPolicyResponse) ProtoMessage() {} -func (*GetPolicyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{74} } +func (*GetPolicyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{86} } func (m *GetPolicyResponse) GetPolicies() []*Policy { if m != nil { @@ -2055,7 +2412,7 @@ type AddPolicyRequest struct { func (m *AddPolicyRequest) Reset() { *m = AddPolicyRequest{} } func (m *AddPolicyRequest) String() string { return proto.CompactTextString(m) } func (*AddPolicyRequest) ProtoMessage() {} -func (*AddPolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{75} } +func (*AddPolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{87} } func (m *AddPolicyRequest) GetPolicy() *Policy { if m != nil { @@ -2077,7 +2434,7 @@ type AddPolicyResponse struct { func (m *AddPolicyResponse) Reset() { *m = AddPolicyResponse{} } func (m *AddPolicyResponse) String() string { return proto.CompactTextString(m) } func (*AddPolicyResponse) ProtoMessage() {} -func (*AddPolicyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{76} } +func (*AddPolicyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{88} } type DeletePolicyRequest struct { Policy *Policy `protobuf:"bytes,1,opt,name=policy" json:"policy,omitempty"` @@ -2090,7 +2447,7 @@ type DeletePolicyRequest struct { func (m *DeletePolicyRequest) Reset() { *m = DeletePolicyRequest{} } func (m *DeletePolicyRequest) String() string { return proto.CompactTextString(m) } func (*DeletePolicyRequest) ProtoMessage() {} -func (*DeletePolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{77} } +func (*DeletePolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{89} } func (m *DeletePolicyRequest) GetPolicy() *Policy { if m != nil { @@ -2119,7 +2476,7 @@ type DeletePolicyResponse struct { func (m *DeletePolicyResponse) Reset() { *m = DeletePolicyResponse{} } func (m *DeletePolicyResponse) String() string { return proto.CompactTextString(m) } func (*DeletePolicyResponse) ProtoMessage() {} -func (*DeletePolicyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{78} } +func (*DeletePolicyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{90} } type ReplacePolicyRequest struct { Policy *Policy `protobuf:"bytes,1,opt,name=policy" json:"policy,omitempty"` @@ -2134,7 +2491,7 @@ type ReplacePolicyRequest struct { func (m *ReplacePolicyRequest) Reset() { *m = ReplacePolicyRequest{} } func (m *ReplacePolicyRequest) String() string { return proto.CompactTextString(m) } func (*ReplacePolicyRequest) ProtoMessage() {} -func (*ReplacePolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{79} } +func (*ReplacePolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{91} } func (m *ReplacePolicyRequest) GetPolicy() *Policy { if m != nil { @@ -2163,7 +2520,7 @@ type ReplacePolicyResponse struct { func (m *ReplacePolicyResponse) Reset() { *m = ReplacePolicyResponse{} } func (m *ReplacePolicyResponse) String() string { return proto.CompactTextString(m) } func (*ReplacePolicyResponse) ProtoMessage() {} -func (*ReplacePolicyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{80} } +func (*ReplacePolicyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{92} } type GetPolicyAssignmentRequest struct { Assignment *PolicyAssignment `protobuf:"bytes,1,opt,name=assignment" json:"assignment,omitempty"` @@ -2172,7 +2529,7 @@ type GetPolicyAssignmentRequest struct { func (m *GetPolicyAssignmentRequest) Reset() { *m = GetPolicyAssignmentRequest{} } func (m *GetPolicyAssignmentRequest) String() string { return proto.CompactTextString(m) } func (*GetPolicyAssignmentRequest) ProtoMessage() {} -func (*GetPolicyAssignmentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{81} } +func (*GetPolicyAssignmentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{93} } func (m *GetPolicyAssignmentRequest) GetAssignment() *PolicyAssignment { if m != nil { @@ -2188,7 +2545,7 @@ type GetPolicyAssignmentResponse struct { func (m *GetPolicyAssignmentResponse) Reset() { *m = GetPolicyAssignmentResponse{} } func (m *GetPolicyAssignmentResponse) String() string { return proto.CompactTextString(m) } func (*GetPolicyAssignmentResponse) ProtoMessage() {} -func (*GetPolicyAssignmentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{82} } +func (*GetPolicyAssignmentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{94} } func (m *GetPolicyAssignmentResponse) GetAssignment() *PolicyAssignment { if m != nil { @@ -2204,7 +2561,7 @@ type AddPolicyAssignmentRequest struct { func (m *AddPolicyAssignmentRequest) Reset() { *m = AddPolicyAssignmentRequest{} } func (m *AddPolicyAssignmentRequest) String() string { return proto.CompactTextString(m) } func (*AddPolicyAssignmentRequest) ProtoMessage() {} -func (*AddPolicyAssignmentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{83} } +func (*AddPolicyAssignmentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{95} } func (m *AddPolicyAssignmentRequest) GetAssignment() *PolicyAssignment { if m != nil { @@ -2219,7 +2576,7 @@ type AddPolicyAssignmentResponse struct { func (m *AddPolicyAssignmentResponse) Reset() { *m = AddPolicyAssignmentResponse{} } func (m *AddPolicyAssignmentResponse) String() string { return proto.CompactTextString(m) } func (*AddPolicyAssignmentResponse) ProtoMessage() {} -func (*AddPolicyAssignmentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{84} } +func (*AddPolicyAssignmentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{96} } type DeletePolicyAssignmentRequest struct { Assignment *PolicyAssignment `protobuf:"bytes,1,opt,name=assignment" json:"assignment,omitempty"` @@ -2229,7 +2586,7 @@ type DeletePolicyAssignmentRequest struct { func (m *DeletePolicyAssignmentRequest) Reset() { *m = DeletePolicyAssignmentRequest{} } func (m *DeletePolicyAssignmentRequest) String() string { return proto.CompactTextString(m) } func (*DeletePolicyAssignmentRequest) ProtoMessage() {} -func (*DeletePolicyAssignmentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{85} } +func (*DeletePolicyAssignmentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{97} } func (m *DeletePolicyAssignmentRequest) GetAssignment() *PolicyAssignment { if m != nil { @@ -2251,7 +2608,7 @@ type DeletePolicyAssignmentResponse struct { func (m *DeletePolicyAssignmentResponse) Reset() { *m = DeletePolicyAssignmentResponse{} } func (m *DeletePolicyAssignmentResponse) String() string { return proto.CompactTextString(m) } func (*DeletePolicyAssignmentResponse) ProtoMessage() {} -func (*DeletePolicyAssignmentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{86} } +func (*DeletePolicyAssignmentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{98} } type ReplacePolicyAssignmentRequest struct { Assignment *PolicyAssignment `protobuf:"bytes,1,opt,name=assignment" json:"assignment,omitempty"` @@ -2260,7 +2617,7 @@ type ReplacePolicyAssignmentRequest struct { func (m *ReplacePolicyAssignmentRequest) Reset() { *m = ReplacePolicyAssignmentRequest{} } func (m *ReplacePolicyAssignmentRequest) String() string { return proto.CompactTextString(m) } func (*ReplacePolicyAssignmentRequest) ProtoMessage() {} -func (*ReplacePolicyAssignmentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{87} } +func (*ReplacePolicyAssignmentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{99} } func (m *ReplacePolicyAssignmentRequest) GetAssignment() *PolicyAssignment { if m != nil { @@ -2276,7 +2633,7 @@ func (m *ReplacePolicyAssignmentResponse) Reset() { *m = ReplacePolicyAs func (m *ReplacePolicyAssignmentResponse) String() string { return proto.CompactTextString(m) } func (*ReplacePolicyAssignmentResponse) ProtoMessage() {} func (*ReplacePolicyAssignmentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor0, []int{88} + return fileDescriptor0, []int{100} } type GetServerRequest struct { @@ -2285,7 +2642,7 @@ type GetServerRequest struct { func (m *GetServerRequest) Reset() { *m = GetServerRequest{} } func (m *GetServerRequest) String() string { return proto.CompactTextString(m) } func (*GetServerRequest) ProtoMessage() {} -func (*GetServerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{89} } +func (*GetServerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{101} } type GetServerResponse struct { Global *Global `protobuf:"bytes,1,opt,name=global" json:"global,omitempty"` @@ -2294,7 +2651,7 @@ type GetServerResponse struct { func (m *GetServerResponse) Reset() { *m = GetServerResponse{} } func (m *GetServerResponse) String() string { return proto.CompactTextString(m) } func (*GetServerResponse) ProtoMessage() {} -func (*GetServerResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{90} } +func (*GetServerResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{102} } func (m *GetServerResponse) GetGlobal() *Global { if m != nil { @@ -2310,7 +2667,7 @@ type StartServerRequest struct { func (m *StartServerRequest) Reset() { *m = StartServerRequest{} } func (m *StartServerRequest) String() string { return proto.CompactTextString(m) } func (*StartServerRequest) ProtoMessage() {} -func (*StartServerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{91} } +func (*StartServerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{103} } func (m *StartServerRequest) GetGlobal() *Global { if m != nil { @@ -2325,7 +2682,7 @@ type StartServerResponse struct { func (m *StartServerResponse) Reset() { *m = StartServerResponse{} } func (m *StartServerResponse) String() string { return proto.CompactTextString(m) } func (*StartServerResponse) ProtoMessage() {} -func (*StartServerResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{92} } +func (*StartServerResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{104} } type StopServerRequest struct { } @@ -2333,7 +2690,7 @@ type StopServerRequest struct { func (m *StopServerRequest) Reset() { *m = StopServerRequest{} } func (m *StopServerRequest) String() string { return proto.CompactTextString(m) } func (*StopServerRequest) ProtoMessage() {} -func (*StopServerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{93} } +func (*StopServerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{105} } type StopServerResponse struct { } @@ -2341,7 +2698,7 @@ type StopServerResponse struct { func (m *StopServerResponse) Reset() { *m = StopServerResponse{} } func (m *StopServerResponse) String() string { return proto.CompactTextString(m) } func (*StopServerResponse) ProtoMessage() {} -func (*StopServerResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{94} } +func (*StopServerResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{106} } type RPKIValidation struct { State RPKIValidation_State `protobuf:"varint,1,opt,name=state,enum=gobgpapi.RPKIValidation_State" json:"state,omitempty"` @@ -2354,7 +2711,7 @@ type RPKIValidation struct { func (m *RPKIValidation) Reset() { *m = RPKIValidation{} } func (m *RPKIValidation) String() string { return proto.CompactTextString(m) } func (*RPKIValidation) ProtoMessage() {} -func (*RPKIValidation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{95} } +func (*RPKIValidation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{107} } func (m *RPKIValidation) GetState() RPKIValidation_State { if m != nil { @@ -2411,12 +2768,30 @@ type Path struct { IsNexthopInvalid bool `protobuf:"varint,17,opt,name=is_nexthop_invalid,json=isNexthopInvalid" json:"is_nexthop_invalid,omitempty"` Identifier uint32 `protobuf:"varint,18,opt,name=identifier" json:"identifier,omitempty"` LocalIdentifier uint32 `protobuf:"varint,19,opt,name=local_identifier,json=localIdentifier" json:"local_identifier,omitempty"` + // One of the following defined in "api/attribute.proto": + // - IPAddressPrefix + // - LabeledIPAddressPrefix + // - EncapsulationNLRI + // - EVPNEthernetAutoDiscoveryRoute + // - EVPNMACIPAdvertisementRoute + // - EVPNInclusiveMulticastEthernetTagRoute + // - EVPNEthernetSegmentRoute + // - EVPNIPPrefixRoute + // - LabeledVPNIPAddressPrefix + // - RouteTargetMembershipNLRI + // - FlowSpecNLRI + // - VPNFlowSpecNLRI + // - OpaqueNLRI + AnyNlri *google_protobuf.Any `protobuf:"bytes,20,opt,name=any_nlri,json=anyNlri" json:"any_nlri,omitempty"` + // Each attribute must be one of *Attribute defined in + // "api/attribute.proto". + AnyPattrs []*google_protobuf.Any `protobuf:"bytes,21,rep,name=any_pattrs,json=anyPattrs" json:"any_pattrs,omitempty"` } func (m *Path) Reset() { *m = Path{} } func (m *Path) String() string { return proto.CompactTextString(m) } func (*Path) ProtoMessage() {} -func (*Path) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{96} } +func (*Path) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{108} } func (m *Path) GetNlri() []byte { if m != nil { @@ -2551,6 +2926,20 @@ func (m *Path) GetLocalIdentifier() uint32 { return 0 } +func (m *Path) GetAnyNlri() *google_protobuf.Any { + if m != nil { + return m.AnyNlri + } + return nil +} + +func (m *Path) GetAnyPattrs() []*google_protobuf.Any { + if m != nil { + return m.AnyPattrs + } + return nil +} + type Destination struct { Prefix string `protobuf:"bytes,1,opt,name=prefix" json:"prefix,omitempty"` Paths []*Path `protobuf:"bytes,2,rep,name=paths" json:"paths,omitempty"` @@ -2561,7 +2950,7 @@ type Destination struct { func (m *Destination) Reset() { *m = Destination{} } func (m *Destination) String() string { return proto.CompactTextString(m) } func (*Destination) ProtoMessage() {} -func (*Destination) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{97} } +func (*Destination) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{109} } func (m *Destination) GetPrefix() string { if m != nil { @@ -2602,7 +2991,7 @@ type Table struct { func (m *Table) Reset() { *m = Table{} } func (m *Table) String() string { return proto.CompactTextString(m) } func (*Table) ProtoMessage() {} -func (*Table) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{98} } +func (*Table) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{110} } func (m *Table) GetType() Resource { if m != nil { @@ -2646,7 +3035,7 @@ type GetRibRequest struct { func (m *GetRibRequest) Reset() { *m = GetRibRequest{} } func (m *GetRibRequest) String() string { return proto.CompactTextString(m) } func (*GetRibRequest) ProtoMessage() {} -func (*GetRibRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{99} } +func (*GetRibRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{111} } func (m *GetRibRequest) GetTable() *Table { if m != nil { @@ -2662,7 +3051,7 @@ type GetRibResponse struct { func (m *GetRibResponse) Reset() { *m = GetRibResponse{} } func (m *GetRibResponse) String() string { return proto.CompactTextString(m) } func (*GetRibResponse) ProtoMessage() {} -func (*GetRibResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{100} } +func (*GetRibResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{112} } func (m *GetRibResponse) GetTable() *Table { if m != nil { @@ -2680,7 +3069,7 @@ type TableLookupPrefix struct { func (m *TableLookupPrefix) Reset() { *m = TableLookupPrefix{} } func (m *TableLookupPrefix) String() string { return proto.CompactTextString(m) } func (*TableLookupPrefix) ProtoMessage() {} -func (*TableLookupPrefix) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{101} } +func (*TableLookupPrefix) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{113} } func (m *TableLookupPrefix) GetPrefix() string { if m != nil { @@ -2706,7 +3095,7 @@ type GetPathRequest struct { func (m *GetPathRequest) Reset() { *m = GetPathRequest{} } func (m *GetPathRequest) String() string { return proto.CompactTextString(m) } func (*GetPathRequest) ProtoMessage() {} -func (*GetPathRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{102} } +func (*GetPathRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{114} } func (m *GetPathRequest) GetType() Resource { if m != nil { @@ -2745,7 +3134,7 @@ type ValidateRibRequest struct { func (m *ValidateRibRequest) Reset() { *m = ValidateRibRequest{} } func (m *ValidateRibRequest) String() string { return proto.CompactTextString(m) } func (*ValidateRibRequest) ProtoMessage() {} -func (*ValidateRibRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{103} } +func (*ValidateRibRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{115} } func (m *ValidateRibRequest) GetType() Resource { if m != nil { @@ -2774,7 +3163,7 @@ type ValidateRibResponse struct { func (m *ValidateRibResponse) Reset() { *m = ValidateRibResponse{} } func (m *ValidateRibResponse) String() string { return proto.CompactTextString(m) } func (*ValidateRibResponse) ProtoMessage() {} -func (*ValidateRibResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{104} } +func (*ValidateRibResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{116} } type Peer struct { // Note: Regarding to the consistency with OpenConfig model, a list of @@ -2797,7 +3186,7 @@ type Peer struct { func (m *Peer) Reset() { *m = Peer{} } func (m *Peer) String() string { return proto.CompactTextString(m) } func (*Peer) ProtoMessage() {} -func (*Peer) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{105} } +func (*Peer) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{117} } func (m *Peer) GetFamilies() []uint32 { if m != nil { @@ -2883,6 +3272,137 @@ func (m *Peer) GetAddPaths() *AddPaths { return nil } +type PeerGroup struct { + // Note: Regarding to the consistency with OpenConfig model, a list of + // address family should be removed from here, and should be configured with + // the list of AfiSafi instead. + Families []uint32 `protobuf:"varint,1,rep,packed,name=families" json:"families,omitempty"` + ApplyPolicy *ApplyPolicy `protobuf:"bytes,2,opt,name=apply_policy,json=applyPolicy" json:"apply_policy,omitempty"` + Conf *PeerGroupConf `protobuf:"bytes,3,opt,name=conf" json:"conf,omitempty"` + EbgpMultihop *EbgpMultihop `protobuf:"bytes,4,opt,name=ebgp_multihop,json=ebgpMultihop" json:"ebgp_multihop,omitempty"` + RouteReflector *RouteReflector `protobuf:"bytes,5,opt,name=route_reflector,json=routeReflector" json:"route_reflector,omitempty"` + Info *PeerGroupState `protobuf:"bytes,6,opt,name=info" json:"info,omitempty"` + Timers *Timers `protobuf:"bytes,7,opt,name=timers" json:"timers,omitempty"` + Transport *Transport `protobuf:"bytes,8,opt,name=transport" json:"transport,omitempty"` + RouteServer *RouteServer `protobuf:"bytes,9,opt,name=route_server,json=routeServer" json:"route_server,omitempty"` + GracefulRestart *GracefulRestart `protobuf:"bytes,10,opt,name=graceful_restart,json=gracefulRestart" json:"graceful_restart,omitempty"` + AfiSafis []*AfiSafi `protobuf:"bytes,11,rep,name=afi_safis,json=afiSafis" json:"afi_safis,omitempty"` + AddPaths *AddPaths `protobuf:"bytes,12,opt,name=add_paths,json=addPaths" json:"add_paths,omitempty"` +} + +func (m *PeerGroup) Reset() { *m = PeerGroup{} } +func (m *PeerGroup) String() string { return proto.CompactTextString(m) } +func (*PeerGroup) ProtoMessage() {} +func (*PeerGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{118} } + +func (m *PeerGroup) GetFamilies() []uint32 { + if m != nil { + return m.Families + } + return nil +} + +func (m *PeerGroup) GetApplyPolicy() *ApplyPolicy { + if m != nil { + return m.ApplyPolicy + } + return nil +} + +func (m *PeerGroup) GetConf() *PeerGroupConf { + if m != nil { + return m.Conf + } + return nil +} + +func (m *PeerGroup) GetEbgpMultihop() *EbgpMultihop { + if m != nil { + return m.EbgpMultihop + } + return nil +} + +func (m *PeerGroup) GetRouteReflector() *RouteReflector { + if m != nil { + return m.RouteReflector + } + return nil +} + +func (m *PeerGroup) GetInfo() *PeerGroupState { + if m != nil { + return m.Info + } + return nil +} + +func (m *PeerGroup) GetTimers() *Timers { + if m != nil { + return m.Timers + } + return nil +} + +func (m *PeerGroup) GetTransport() *Transport { + if m != nil { + return m.Transport + } + return nil +} + +func (m *PeerGroup) GetRouteServer() *RouteServer { + if m != nil { + return m.RouteServer + } + return nil +} + +func (m *PeerGroup) GetGracefulRestart() *GracefulRestart { + if m != nil { + return m.GracefulRestart + } + return nil +} + +func (m *PeerGroup) GetAfiSafis() []*AfiSafi { + if m != nil { + return m.AfiSafis + } + return nil +} + +func (m *PeerGroup) GetAddPaths() *AddPaths { + if m != nil { + return m.AddPaths + } + return nil +} + +type DynamicNeighbor struct { + Prefix string `protobuf:"bytes,1,opt,name=prefix" json:"prefix,omitempty"` + PeerGroup string `protobuf:"bytes,2,opt,name=peer_group,json=peerGroup" json:"peer_group,omitempty"` +} + +func (m *DynamicNeighbor) Reset() { *m = DynamicNeighbor{} } +func (m *DynamicNeighbor) String() string { return proto.CompactTextString(m) } +func (*DynamicNeighbor) ProtoMessage() {} +func (*DynamicNeighbor) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{119} } + +func (m *DynamicNeighbor) GetPrefix() string { + if m != nil { + return m.Prefix + } + return "" +} + +func (m *DynamicNeighbor) GetPeerGroup() string { + if m != nil { + return m.PeerGroup + } + return "" +} + type ApplyPolicy struct { InPolicy *PolicyAssignment `protobuf:"bytes,1,opt,name=in_policy,json=inPolicy" json:"in_policy,omitempty"` ExportPolicy *PolicyAssignment `protobuf:"bytes,2,opt,name=export_policy,json=exportPolicy" json:"export_policy,omitempty"` @@ -2892,7 +3412,7 @@ type ApplyPolicy struct { func (m *ApplyPolicy) Reset() { *m = ApplyPolicy{} } func (m *ApplyPolicy) String() string { return proto.CompactTextString(m) } func (*ApplyPolicy) ProtoMessage() {} -func (*ApplyPolicy) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{106} } +func (*ApplyPolicy) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{120} } func (m *ApplyPolicy) GetInPolicy() *PolicyAssignment { if m != nil { @@ -2924,7 +3444,7 @@ type PrefixLimit struct { func (m *PrefixLimit) Reset() { *m = PrefixLimit{} } func (m *PrefixLimit) String() string { return proto.CompactTextString(m) } func (*PrefixLimit) ProtoMessage() {} -func (*PrefixLimit) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{107} } +func (*PrefixLimit) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{121} } func (m *PrefixLimit) GetFamily() uint32 { if m != nil { @@ -2958,9 +3478,11 @@ type PeerConf struct { RemovePrivateAs PeerConf_RemovePrivateAs `protobuf:"varint,8,opt,name=remove_private_as,json=removePrivateAs,enum=gobgpapi.PeerConf_RemovePrivateAs" json:"remove_private_as,omitempty"` RouteFlapDamping bool `protobuf:"varint,9,opt,name=route_flap_damping,json=routeFlapDamping" json:"route_flap_damping,omitempty"` SendCommunity uint32 `protobuf:"varint,10,opt,name=send_community,json=sendCommunity" json:"send_community,omitempty"` - RemoteCap [][]byte `protobuf:"bytes,11,rep,name=remote_cap,json=remoteCap,proto3" json:"remote_cap,omitempty"` - LocalCap [][]byte `protobuf:"bytes,12,rep,name=local_cap,json=localCap,proto3" json:"local_cap,omitempty"` - Id string `protobuf:"bytes,13,opt,name=id" json:"id,omitempty"` + // Each attribute must be one of *Capability defined in + // "api/capability.proto". + RemoteCap []*google_protobuf.Any `protobuf:"bytes,11,rep,name=remote_cap,json=remoteCap" json:"remote_cap,omitempty"` + LocalCap []*google_protobuf.Any `protobuf:"bytes,12,rep,name=local_cap,json=localCap" json:"local_cap,omitempty"` + Id string `protobuf:"bytes,13,opt,name=id" json:"id,omitempty"` // Note: Regarding to the consistency with OpenConfig model, list of // PrefixLimit should be removed from here, and list of PrefixLimit in // AfiSafi should be used instead. @@ -2975,7 +3497,7 @@ type PeerConf struct { func (m *PeerConf) Reset() { *m = PeerConf{} } func (m *PeerConf) String() string { return proto.CompactTextString(m) } func (*PeerConf) ProtoMessage() {} -func (*PeerConf) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{108} } +func (*PeerConf) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{122} } func (m *PeerConf) GetAuthPassword() string { if m != nil { @@ -3047,14 +3569,14 @@ func (m *PeerConf) GetSendCommunity() uint32 { return 0 } -func (m *PeerConf) GetRemoteCap() [][]byte { +func (m *PeerConf) GetRemoteCap() []*google_protobuf.Any { if m != nil { return m.RemoteCap } return nil } -func (m *PeerConf) GetLocalCap() [][]byte { +func (m *PeerConf) GetLocalCap() []*google_protobuf.Any { if m != nil { return m.LocalCap } @@ -3110,6 +3632,182 @@ func (m *PeerConf) GetReplacePeerAs() bool { return false } +type PeerGroupConf struct { + AuthPassword string `protobuf:"bytes,1,opt,name=auth_password,json=authPassword" json:"auth_password,omitempty"` + Description string `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"` + LocalAs uint32 `protobuf:"varint,3,opt,name=local_as,json=localAs" json:"local_as,omitempty"` + PeerAs uint32 `protobuf:"varint,5,opt,name=peer_as,json=peerAs" json:"peer_as,omitempty"` + PeerGroupName string `protobuf:"bytes,6,opt,name=peer_group_name,json=peerGroupName" json:"peer_group_name,omitempty"` + PeerType uint32 `protobuf:"varint,7,opt,name=peer_type,json=peerType" json:"peer_type,omitempty"` + RemovePrivateAs PeerGroupConf_RemovePrivateAs `protobuf:"varint,8,opt,name=remove_private_as,json=removePrivateAs,enum=gobgpapi.PeerGroupConf_RemovePrivateAs" json:"remove_private_as,omitempty"` + RouteFlapDamping bool `protobuf:"varint,9,opt,name=route_flap_damping,json=routeFlapDamping" json:"route_flap_damping,omitempty"` + SendCommunity uint32 `protobuf:"varint,10,opt,name=send_community,json=sendCommunity" json:"send_community,omitempty"` +} + +func (m *PeerGroupConf) Reset() { *m = PeerGroupConf{} } +func (m *PeerGroupConf) String() string { return proto.CompactTextString(m) } +func (*PeerGroupConf) ProtoMessage() {} +func (*PeerGroupConf) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{123} } + +func (m *PeerGroupConf) GetAuthPassword() string { + if m != nil { + return m.AuthPassword + } + return "" +} + +func (m *PeerGroupConf) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *PeerGroupConf) GetLocalAs() uint32 { + if m != nil { + return m.LocalAs + } + return 0 +} + +func (m *PeerGroupConf) GetPeerAs() uint32 { + if m != nil { + return m.PeerAs + } + return 0 +} + +func (m *PeerGroupConf) GetPeerGroupName() string { + if m != nil { + return m.PeerGroupName + } + return "" +} + +func (m *PeerGroupConf) GetPeerType() uint32 { + if m != nil { + return m.PeerType + } + return 0 +} + +func (m *PeerGroupConf) GetRemovePrivateAs() PeerGroupConf_RemovePrivateAs { + if m != nil { + return m.RemovePrivateAs + } + return PeerGroupConf_NONE +} + +func (m *PeerGroupConf) GetRouteFlapDamping() bool { + if m != nil { + return m.RouteFlapDamping + } + return false +} + +func (m *PeerGroupConf) GetSendCommunity() uint32 { + if m != nil { + return m.SendCommunity + } + return 0 +} + +type PeerGroupState struct { + AuthPassword string `protobuf:"bytes,1,opt,name=auth_password,json=authPassword" json:"auth_password,omitempty"` + Description string `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"` + LocalAs uint32 `protobuf:"varint,3,opt,name=local_as,json=localAs" json:"local_as,omitempty"` + PeerAs uint32 `protobuf:"varint,5,opt,name=peer_as,json=peerAs" json:"peer_as,omitempty"` + PeerGroupName string `protobuf:"bytes,6,opt,name=peer_group_name,json=peerGroupName" json:"peer_group_name,omitempty"` + PeerType uint32 `protobuf:"varint,7,opt,name=peer_type,json=peerType" json:"peer_type,omitempty"` + RemovePrivateAs PeerGroupState_RemovePrivateAs `protobuf:"varint,8,opt,name=remove_private_as,json=removePrivateAs,enum=gobgpapi.PeerGroupState_RemovePrivateAs" json:"remove_private_as,omitempty"` + RouteFlapDamping bool `protobuf:"varint,9,opt,name=route_flap_damping,json=routeFlapDamping" json:"route_flap_damping,omitempty"` + SendCommunity uint32 `protobuf:"varint,10,opt,name=send_community,json=sendCommunity" json:"send_community,omitempty"` + TotalPaths uint32 `protobuf:"varint,11,opt,name=total_paths,json=totalPaths" json:"total_paths,omitempty"` + TotalPrefixes uint32 `protobuf:"varint,12,opt,name=total_prefixes,json=totalPrefixes" json:"total_prefixes,omitempty"` +} + +func (m *PeerGroupState) Reset() { *m = PeerGroupState{} } +func (m *PeerGroupState) String() string { return proto.CompactTextString(m) } +func (*PeerGroupState) ProtoMessage() {} +func (*PeerGroupState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{124} } + +func (m *PeerGroupState) GetAuthPassword() string { + if m != nil { + return m.AuthPassword + } + return "" +} + +func (m *PeerGroupState) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *PeerGroupState) GetLocalAs() uint32 { + if m != nil { + return m.LocalAs + } + return 0 +} + +func (m *PeerGroupState) GetPeerAs() uint32 { + if m != nil { + return m.PeerAs + } + return 0 +} + +func (m *PeerGroupState) GetPeerGroupName() string { + if m != nil { + return m.PeerGroupName + } + return "" +} + +func (m *PeerGroupState) GetPeerType() uint32 { + if m != nil { + return m.PeerType + } + return 0 +} + +func (m *PeerGroupState) GetRemovePrivateAs() PeerGroupState_RemovePrivateAs { + if m != nil { + return m.RemovePrivateAs + } + return PeerGroupState_NONE +} + +func (m *PeerGroupState) GetRouteFlapDamping() bool { + if m != nil { + return m.RouteFlapDamping + } + return false +} + +func (m *PeerGroupState) GetSendCommunity() uint32 { + if m != nil { + return m.SendCommunity + } + return 0 +} + +func (m *PeerGroupState) GetTotalPaths() uint32 { + if m != nil { + return m.TotalPaths + } + return 0 +} + +func (m *PeerGroupState) GetTotalPrefixes() uint32 { + if m != nil { + return m.TotalPrefixes + } + return 0 +} + type EbgpMultihop struct { Enabled bool `protobuf:"varint,1,opt,name=enabled" json:"enabled,omitempty"` MultihopTtl uint32 `protobuf:"varint,2,opt,name=multihop_ttl,json=multihopTtl" json:"multihop_ttl,omitempty"` @@ -3118,7 +3816,7 @@ type EbgpMultihop struct { func (m *EbgpMultihop) Reset() { *m = EbgpMultihop{} } func (m *EbgpMultihop) String() string { return proto.CompactTextString(m) } func (*EbgpMultihop) ProtoMessage() {} -func (*EbgpMultihop) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{109} } +func (*EbgpMultihop) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{125} } func (m *EbgpMultihop) GetEnabled() bool { if m != nil { @@ -3142,7 +3840,7 @@ type RouteReflector struct { func (m *RouteReflector) Reset() { *m = RouteReflector{} } func (m *RouteReflector) String() string { return proto.CompactTextString(m) } func (*RouteReflector) ProtoMessage() {} -func (*RouteReflector) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{110} } +func (*RouteReflector) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{126} } func (m *RouteReflector) GetRouteReflectorClient() bool { if m != nil { @@ -3185,7 +3883,7 @@ type PeerState struct { func (m *PeerState) Reset() { *m = PeerState{} } func (m *PeerState) String() string { return proto.CompactTextString(m) } func (*PeerState) ProtoMessage() {} -func (*PeerState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{111} } +func (*PeerState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{127} } func (m *PeerState) GetAuthPassword() string { if m != nil { @@ -3342,7 +4040,7 @@ type Messages struct { func (m *Messages) Reset() { *m = Messages{} } func (m *Messages) String() string { return proto.CompactTextString(m) } func (*Messages) ProtoMessage() {} -func (*Messages) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{112} } +func (*Messages) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{128} } func (m *Messages) GetReceived() *Message { if m != nil { @@ -3371,7 +4069,7 @@ type Message struct { func (m *Message) Reset() { *m = Message{} } func (m *Message) String() string { return proto.CompactTextString(m) } func (*Message) ProtoMessage() {} -func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{113} } +func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{129} } func (m *Message) GetNOTIFICATION() uint64 { if m != nil { @@ -3430,7 +4128,7 @@ type Queues struct { func (m *Queues) Reset() { *m = Queues{} } func (m *Queues) String() string { return proto.CompactTextString(m) } func (*Queues) ProtoMessage() {} -func (*Queues) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{114} } +func (*Queues) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{130} } func (m *Queues) GetInput() uint32 { if m != nil { @@ -3454,7 +4152,7 @@ type Timers struct { func (m *Timers) Reset() { *m = Timers{} } func (m *Timers) String() string { return proto.CompactTextString(m) } func (*Timers) ProtoMessage() {} -func (*Timers) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{115} } +func (*Timers) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{131} } func (m *Timers) GetConfig() *TimersConfig { if m != nil { @@ -3480,7 +4178,7 @@ type TimersConfig struct { func (m *TimersConfig) Reset() { *m = TimersConfig{} } func (m *TimersConfig) String() string { return proto.CompactTextString(m) } func (*TimersConfig) ProtoMessage() {} -func (*TimersConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{116} } +func (*TimersConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{132} } func (m *TimersConfig) GetConnectRetry() uint64 { if m != nil { @@ -3523,7 +4221,7 @@ type TimersState struct { func (m *TimersState) Reset() { *m = TimersState{} } func (m *TimersState) String() string { return proto.CompactTextString(m) } func (*TimersState) ProtoMessage() {} -func (*TimersState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{117} } +func (*TimersState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{133} } func (m *TimersState) GetConnectRetry() uint64 { if m != nil { @@ -3587,7 +4285,7 @@ type Transport struct { func (m *Transport) Reset() { *m = Transport{} } func (m *Transport) String() string { return proto.CompactTextString(m) } func (*Transport) ProtoMessage() {} -func (*Transport) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{118} } +func (*Transport) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{134} } func (m *Transport) GetLocalAddress() string { if m != nil { @@ -3645,7 +4343,7 @@ type RouteServer struct { func (m *RouteServer) Reset() { *m = RouteServer{} } func (m *RouteServer) String() string { return proto.CompactTextString(m) } func (*RouteServer) ProtoMessage() {} -func (*RouteServer) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{119} } +func (*RouteServer) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{135} } func (m *RouteServer) GetRouteServerClient() bool { if m != nil { @@ -3661,12 +4359,17 @@ type GracefulRestart struct { DeferralTime uint32 `protobuf:"varint,4,opt,name=deferral_time,json=deferralTime" json:"deferral_time,omitempty"` NotificationEnabled bool `protobuf:"varint,5,opt,name=notification_enabled,json=notificationEnabled" json:"notification_enabled,omitempty"` LonglivedEnabled bool `protobuf:"varint,6,opt,name=longlived_enabled,json=longlivedEnabled" json:"longlived_enabled,omitempty"` + StaleRoutesTime uint32 `protobuf:"varint,7,opt,name=stale_routes_time,json=staleRoutesTime" json:"stale_routes_time,omitempty"` + PeerRestartTime uint32 `protobuf:"varint,8,opt,name=peer_restart_time,json=peerRestartTime" json:"peer_restart_time,omitempty"` + PeerRestarting bool `protobuf:"varint,9,opt,name=peer_restarting,json=peerRestarting" json:"peer_restarting,omitempty"` + LocalRestarting bool `protobuf:"varint,10,opt,name=local_restarting,json=localRestarting" json:"local_restarting,omitempty"` + Mode string `protobuf:"bytes,11,opt,name=mode" json:"mode,omitempty"` } func (m *GracefulRestart) Reset() { *m = GracefulRestart{} } func (m *GracefulRestart) String() string { return proto.CompactTextString(m) } func (*GracefulRestart) ProtoMessage() {} -func (*GracefulRestart) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{120} } +func (*GracefulRestart) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{136} } func (m *GracefulRestart) GetEnabled() bool { if m != nil { @@ -3710,6 +4413,41 @@ func (m *GracefulRestart) GetLonglivedEnabled() bool { return false } +func (m *GracefulRestart) GetStaleRoutesTime() uint32 { + if m != nil { + return m.StaleRoutesTime + } + return 0 +} + +func (m *GracefulRestart) GetPeerRestartTime() uint32 { + if m != nil { + return m.PeerRestartTime + } + return 0 +} + +func (m *GracefulRestart) GetPeerRestarting() bool { + if m != nil { + return m.PeerRestarting + } + return false +} + +func (m *GracefulRestart) GetLocalRestarting() bool { + if m != nil { + return m.LocalRestarting + } + return false +} + +func (m *GracefulRestart) GetMode() string { + if m != nil { + return m.Mode + } + return "" +} + type MpGracefulRestartConfig struct { Enabled bool `protobuf:"varint,1,opt,name=enabled" json:"enabled,omitempty"` } @@ -3717,7 +4455,7 @@ type MpGracefulRestartConfig struct { func (m *MpGracefulRestartConfig) Reset() { *m = MpGracefulRestartConfig{} } func (m *MpGracefulRestartConfig) String() string { return proto.CompactTextString(m) } func (*MpGracefulRestartConfig) ProtoMessage() {} -func (*MpGracefulRestartConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{121} } +func (*MpGracefulRestartConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{137} } func (m *MpGracefulRestartConfig) GetEnabled() bool { if m != nil { @@ -3737,7 +4475,7 @@ type MpGracefulRestartState struct { func (m *MpGracefulRestartState) Reset() { *m = MpGracefulRestartState{} } func (m *MpGracefulRestartState) String() string { return proto.CompactTextString(m) } func (*MpGracefulRestartState) ProtoMessage() {} -func (*MpGracefulRestartState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{122} } +func (*MpGracefulRestartState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{138} } func (m *MpGracefulRestartState) GetEnabled() bool { if m != nil { @@ -3782,7 +4520,7 @@ type MpGracefulRestart struct { func (m *MpGracefulRestart) Reset() { *m = MpGracefulRestart{} } func (m *MpGracefulRestart) String() string { return proto.CompactTextString(m) } func (*MpGracefulRestart) ProtoMessage() {} -func (*MpGracefulRestart) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{123} } +func (*MpGracefulRestart) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{139} } func (m *MpGracefulRestart) GetConfig() *MpGracefulRestartConfig { if m != nil { @@ -3806,7 +4544,7 @@ type AfiSafiConfig struct { func (m *AfiSafiConfig) Reset() { *m = AfiSafiConfig{} } func (m *AfiSafiConfig) String() string { return proto.CompactTextString(m) } func (*AfiSafiConfig) ProtoMessage() {} -func (*AfiSafiConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{124} } +func (*AfiSafiConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{140} } func (m *AfiSafiConfig) GetFamily() uint32 { if m != nil { @@ -3832,7 +4570,7 @@ type AfiSafiState struct { func (m *AfiSafiState) Reset() { *m = AfiSafiState{} } func (m *AfiSafiState) String() string { return proto.CompactTextString(m) } func (*AfiSafiState) ProtoMessage() {} -func (*AfiSafiState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{125} } +func (*AfiSafiState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{141} } func (m *AfiSafiState) GetFamily() uint32 { if m != nil { @@ -3863,18 +4601,19 @@ func (m *AfiSafiState) GetTotalPrefixes() uint32 { } type RouteSelectionOptionsConfig struct { - AlwaysCompareMed bool `protobuf:"varint,1,opt,name=always_compare_med,json=alwaysCompareMed" json:"always_compare_med,omitempty"` - IgnoreAsPathLength bool `protobuf:"varint,2,opt,name=ignore_as_path_length,json=ignoreAsPathLength" json:"ignore_as_path_length,omitempty"` - ExternalCompareRouterId bool `protobuf:"varint,3,opt,name=external_compare_router_id,json=externalCompareRouterId" json:"external_compare_router_id,omitempty"` - AdvertiseInactiveRoutes bool `protobuf:"varint,4,opt,name=advertise_inactive_routes,json=advertiseInactiveRoutes" json:"advertise_inactive_routes,omitempty"` - EnableAigp bool `protobuf:"varint,5,opt,name=enable_aigp,json=enableAigp" json:"enable_aigp,omitempty"` - IgnoreNextHopIgpMetric bool `protobuf:"varint,6,opt,name=ignore_next_hop_igp_metric,json=ignoreNextHopIgpMetric" json:"ignore_next_hop_igp_metric,omitempty"` + AlwaysCompareMed bool `protobuf:"varint,1,opt,name=always_compare_med,json=alwaysCompareMed" json:"always_compare_med,omitempty"` + IgnoreAsPathLength bool `protobuf:"varint,2,opt,name=ignore_as_path_length,json=ignoreAsPathLength" json:"ignore_as_path_length,omitempty"` + ExternalCompareRouterId bool `protobuf:"varint,3,opt,name=external_compare_router_id,json=externalCompareRouterId" json:"external_compare_router_id,omitempty"` + AdvertiseInactiveRoutes bool `protobuf:"varint,4,opt,name=advertise_inactive_routes,json=advertiseInactiveRoutes" json:"advertise_inactive_routes,omitempty"` + EnableAigp bool `protobuf:"varint,5,opt,name=enable_aigp,json=enableAigp" json:"enable_aigp,omitempty"` + IgnoreNextHopIgpMetric bool `protobuf:"varint,6,opt,name=ignore_next_hop_igp_metric,json=ignoreNextHopIgpMetric" json:"ignore_next_hop_igp_metric,omitempty"` + DisableBestPathSelection bool `protobuf:"varint,7,opt,name=disable_best_path_selection,json=disableBestPathSelection" json:"disable_best_path_selection,omitempty"` } func (m *RouteSelectionOptionsConfig) Reset() { *m = RouteSelectionOptionsConfig{} } func (m *RouteSelectionOptionsConfig) String() string { return proto.CompactTextString(m) } func (*RouteSelectionOptionsConfig) ProtoMessage() {} -func (*RouteSelectionOptionsConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{126} } +func (*RouteSelectionOptionsConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{142} } func (m *RouteSelectionOptionsConfig) GetAlwaysCompareMed() bool { if m != nil { @@ -3918,19 +4657,27 @@ func (m *RouteSelectionOptionsConfig) GetIgnoreNextHopIgpMetric() bool { return false } +func (m *RouteSelectionOptionsConfig) GetDisableBestPathSelection() bool { + if m != nil { + return m.DisableBestPathSelection + } + return false +} + type RouteSelectionOptionsState struct { - AlwaysCompareMed bool `protobuf:"varint,1,opt,name=always_compare_med,json=alwaysCompareMed" json:"always_compare_med,omitempty"` - IgnoreAsPathLength bool `protobuf:"varint,2,opt,name=ignore_as_path_length,json=ignoreAsPathLength" json:"ignore_as_path_length,omitempty"` - ExternalCompareRouterId bool `protobuf:"varint,3,opt,name=external_compare_router_id,json=externalCompareRouterId" json:"external_compare_router_id,omitempty"` - AdvertiseInactiveRoutes bool `protobuf:"varint,4,opt,name=advertise_inactive_routes,json=advertiseInactiveRoutes" json:"advertise_inactive_routes,omitempty"` - EnableAigp bool `protobuf:"varint,5,opt,name=enable_aigp,json=enableAigp" json:"enable_aigp,omitempty"` - IgnoreNextHopIgpMetric bool `protobuf:"varint,6,opt,name=ignore_next_hop_igp_metric,json=ignoreNextHopIgpMetric" json:"ignore_next_hop_igp_metric,omitempty"` + AlwaysCompareMed bool `protobuf:"varint,1,opt,name=always_compare_med,json=alwaysCompareMed" json:"always_compare_med,omitempty"` + IgnoreAsPathLength bool `protobuf:"varint,2,opt,name=ignore_as_path_length,json=ignoreAsPathLength" json:"ignore_as_path_length,omitempty"` + ExternalCompareRouterId bool `protobuf:"varint,3,opt,name=external_compare_router_id,json=externalCompareRouterId" json:"external_compare_router_id,omitempty"` + AdvertiseInactiveRoutes bool `protobuf:"varint,4,opt,name=advertise_inactive_routes,json=advertiseInactiveRoutes" json:"advertise_inactive_routes,omitempty"` + EnableAigp bool `protobuf:"varint,5,opt,name=enable_aigp,json=enableAigp" json:"enable_aigp,omitempty"` + IgnoreNextHopIgpMetric bool `protobuf:"varint,6,opt,name=ignore_next_hop_igp_metric,json=ignoreNextHopIgpMetric" json:"ignore_next_hop_igp_metric,omitempty"` + DisableBestPathSelection bool `protobuf:"varint,7,opt,name=disable_best_path_selection,json=disableBestPathSelection" json:"disable_best_path_selection,omitempty"` } func (m *RouteSelectionOptionsState) Reset() { *m = RouteSelectionOptionsState{} } func (m *RouteSelectionOptionsState) String() string { return proto.CompactTextString(m) } func (*RouteSelectionOptionsState) ProtoMessage() {} -func (*RouteSelectionOptionsState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{127} } +func (*RouteSelectionOptionsState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{143} } func (m *RouteSelectionOptionsState) GetAlwaysCompareMed() bool { if m != nil { @@ -3974,6 +4721,13 @@ func (m *RouteSelectionOptionsState) GetIgnoreNextHopIgpMetric() bool { return false } +func (m *RouteSelectionOptionsState) GetDisableBestPathSelection() bool { + if m != nil { + return m.DisableBestPathSelection + } + return false +} + type RouteSelectionOptions struct { Config *RouteSelectionOptionsConfig `protobuf:"bytes,1,opt,name=config" json:"config,omitempty"` State *RouteSelectionOptionsState `protobuf:"bytes,2,opt,name=state" json:"state,omitempty"` @@ -3982,7 +4736,7 @@ type RouteSelectionOptions struct { func (m *RouteSelectionOptions) Reset() { *m = RouteSelectionOptions{} } func (m *RouteSelectionOptions) String() string { return proto.CompactTextString(m) } func (*RouteSelectionOptions) ProtoMessage() {} -func (*RouteSelectionOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{128} } +func (*RouteSelectionOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{144} } func (m *RouteSelectionOptions) GetConfig() *RouteSelectionOptionsConfig { if m != nil { @@ -4005,7 +4759,7 @@ type UseMultiplePathsConfig struct { func (m *UseMultiplePathsConfig) Reset() { *m = UseMultiplePathsConfig{} } func (m *UseMultiplePathsConfig) String() string { return proto.CompactTextString(m) } func (*UseMultiplePathsConfig) ProtoMessage() {} -func (*UseMultiplePathsConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{129} } +func (*UseMultiplePathsConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{145} } func (m *UseMultiplePathsConfig) GetEnabled() bool { if m != nil { @@ -4021,7 +4775,7 @@ type UseMultiplePathsState struct { func (m *UseMultiplePathsState) Reset() { *m = UseMultiplePathsState{} } func (m *UseMultiplePathsState) String() string { return proto.CompactTextString(m) } func (*UseMultiplePathsState) ProtoMessage() {} -func (*UseMultiplePathsState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{130} } +func (*UseMultiplePathsState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{146} } func (m *UseMultiplePathsState) GetEnabled() bool { if m != nil { @@ -4038,7 +4792,7 @@ type EbgpConfig struct { func (m *EbgpConfig) Reset() { *m = EbgpConfig{} } func (m *EbgpConfig) String() string { return proto.CompactTextString(m) } func (*EbgpConfig) ProtoMessage() {} -func (*EbgpConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{131} } +func (*EbgpConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{147} } func (m *EbgpConfig) GetAllowMultipleAs() bool { if m != nil { @@ -4062,7 +4816,7 @@ type EbgpState struct { func (m *EbgpState) Reset() { *m = EbgpState{} } func (m *EbgpState) String() string { return proto.CompactTextString(m) } func (*EbgpState) ProtoMessage() {} -func (*EbgpState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{132} } +func (*EbgpState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{148} } func (m *EbgpState) GetAllowMultipleAs() bool { if m != nil { @@ -4086,7 +4840,7 @@ type Ebgp struct { func (m *Ebgp) Reset() { *m = Ebgp{} } func (m *Ebgp) String() string { return proto.CompactTextString(m) } func (*Ebgp) ProtoMessage() {} -func (*Ebgp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{133} } +func (*Ebgp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{149} } func (m *Ebgp) GetConfig() *EbgpConfig { if m != nil { @@ -4109,7 +4863,7 @@ type IbgpConfig struct { func (m *IbgpConfig) Reset() { *m = IbgpConfig{} } func (m *IbgpConfig) String() string { return proto.CompactTextString(m) } func (*IbgpConfig) ProtoMessage() {} -func (*IbgpConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{134} } +func (*IbgpConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{150} } func (m *IbgpConfig) GetMaximumPaths() uint32 { if m != nil { @@ -4125,7 +4879,7 @@ type IbgpState struct { func (m *IbgpState) Reset() { *m = IbgpState{} } func (m *IbgpState) String() string { return proto.CompactTextString(m) } func (*IbgpState) ProtoMessage() {} -func (*IbgpState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{135} } +func (*IbgpState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{151} } func (m *IbgpState) GetMaximumPaths() uint32 { if m != nil { @@ -4142,7 +4896,7 @@ type Ibgp struct { func (m *Ibgp) Reset() { *m = Ibgp{} } func (m *Ibgp) String() string { return proto.CompactTextString(m) } func (*Ibgp) ProtoMessage() {} -func (*Ibgp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{136} } +func (*Ibgp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{152} } func (m *Ibgp) GetConfig() *IbgpConfig { if m != nil { @@ -4168,7 +4922,7 @@ type UseMultiplePaths struct { func (m *UseMultiplePaths) Reset() { *m = UseMultiplePaths{} } func (m *UseMultiplePaths) String() string { return proto.CompactTextString(m) } func (*UseMultiplePaths) ProtoMessage() {} -func (*UseMultiplePaths) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{137} } +func (*UseMultiplePaths) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{153} } func (m *UseMultiplePaths) GetConfig() *UseMultiplePathsConfig { if m != nil { @@ -4205,7 +4959,7 @@ type RouteTargetMembershipConfig struct { func (m *RouteTargetMembershipConfig) Reset() { *m = RouteTargetMembershipConfig{} } func (m *RouteTargetMembershipConfig) String() string { return proto.CompactTextString(m) } func (*RouteTargetMembershipConfig) ProtoMessage() {} -func (*RouteTargetMembershipConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{138} } +func (*RouteTargetMembershipConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{154} } func (m *RouteTargetMembershipConfig) GetDeferralTime() uint32 { if m != nil { @@ -4221,7 +4975,7 @@ type RouteTargetMembershipState struct { func (m *RouteTargetMembershipState) Reset() { *m = RouteTargetMembershipState{} } func (m *RouteTargetMembershipState) String() string { return proto.CompactTextString(m) } func (*RouteTargetMembershipState) ProtoMessage() {} -func (*RouteTargetMembershipState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{139} } +func (*RouteTargetMembershipState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{155} } func (m *RouteTargetMembershipState) GetDeferralTime() uint32 { if m != nil { @@ -4238,7 +4992,7 @@ type RouteTargetMembership struct { func (m *RouteTargetMembership) Reset() { *m = RouteTargetMembership{} } func (m *RouteTargetMembership) String() string { return proto.CompactTextString(m) } func (*RouteTargetMembership) ProtoMessage() {} -func (*RouteTargetMembership) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{140} } +func (*RouteTargetMembership) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{156} } func (m *RouteTargetMembership) GetConfig() *RouteTargetMembershipConfig { if m != nil { @@ -4263,7 +5017,7 @@ func (m *LongLivedGracefulRestartConfig) Reset() { *m = LongLivedGracefu func (m *LongLivedGracefulRestartConfig) String() string { return proto.CompactTextString(m) } func (*LongLivedGracefulRestartConfig) ProtoMessage() {} func (*LongLivedGracefulRestartConfig) Descriptor() ([]byte, []int) { - return fileDescriptor0, []int{141} + return fileDescriptor0, []int{157} } func (m *LongLivedGracefulRestartConfig) GetEnabled() bool { @@ -4291,7 +5045,7 @@ type LongLivedGracefulRestartState struct { func (m *LongLivedGracefulRestartState) Reset() { *m = LongLivedGracefulRestartState{} } func (m *LongLivedGracefulRestartState) String() string { return proto.CompactTextString(m) } func (*LongLivedGracefulRestartState) ProtoMessage() {} -func (*LongLivedGracefulRestartState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{142} } +func (*LongLivedGracefulRestartState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{158} } func (m *LongLivedGracefulRestartState) GetEnabled() bool { if m != nil { @@ -4336,7 +5090,7 @@ type LongLivedGracefulRestart struct { func (m *LongLivedGracefulRestart) Reset() { *m = LongLivedGracefulRestart{} } func (m *LongLivedGracefulRestart) String() string { return proto.CompactTextString(m) } func (*LongLivedGracefulRestart) ProtoMessage() {} -func (*LongLivedGracefulRestart) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{143} } +func (*LongLivedGracefulRestart) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{159} } func (m *LongLivedGracefulRestart) GetConfig() *LongLivedGracefulRestartConfig { if m != nil { @@ -4379,7 +5133,7 @@ type AfiSafi struct { func (m *AfiSafi) Reset() { *m = AfiSafi{} } func (m *AfiSafi) String() string { return proto.CompactTextString(m) } func (*AfiSafi) ProtoMessage() {} -func (*AfiSafi) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{144} } +func (*AfiSafi) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{160} } func (m *AfiSafi) GetMpGracefulRestart() *MpGracefulRestart { if m != nil { @@ -4452,7 +5206,7 @@ type AddPathsConfig struct { func (m *AddPathsConfig) Reset() { *m = AddPathsConfig{} } func (m *AddPathsConfig) String() string { return proto.CompactTextString(m) } func (*AddPathsConfig) ProtoMessage() {} -func (*AddPathsConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{145} } +func (*AddPathsConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{161} } func (m *AddPathsConfig) GetReceive() bool { if m != nil { @@ -4476,7 +5230,7 @@ type AddPathsState struct { func (m *AddPathsState) Reset() { *m = AddPathsState{} } func (m *AddPathsState) String() string { return proto.CompactTextString(m) } func (*AddPathsState) ProtoMessage() {} -func (*AddPathsState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{146} } +func (*AddPathsState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{162} } func (m *AddPathsState) GetReceive() bool { if m != nil { @@ -4500,7 +5254,7 @@ type AddPaths struct { func (m *AddPaths) Reset() { *m = AddPaths{} } func (m *AddPaths) String() string { return proto.CompactTextString(m) } func (*AddPaths) ProtoMessage() {} -func (*AddPaths) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{147} } +func (*AddPaths) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{163} } func (m *AddPaths) GetConfig() *AddPathsConfig { if m != nil { @@ -4525,7 +5279,7 @@ type Prefix struct { func (m *Prefix) Reset() { *m = Prefix{} } func (m *Prefix) String() string { return proto.CompactTextString(m) } func (*Prefix) ProtoMessage() {} -func (*Prefix) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{148} } +func (*Prefix) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{164} } func (m *Prefix) GetIpPrefix() string { if m != nil { @@ -4558,7 +5312,7 @@ type DefinedSet struct { func (m *DefinedSet) Reset() { *m = DefinedSet{} } func (m *DefinedSet) String() string { return proto.CompactTextString(m) } func (*DefinedSet) ProtoMessage() {} -func (*DefinedSet) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{149} } +func (*DefinedSet) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{165} } func (m *DefinedSet) GetType() DefinedType { if m != nil { @@ -4596,7 +5350,7 @@ type MatchSet struct { func (m *MatchSet) Reset() { *m = MatchSet{} } func (m *MatchSet) String() string { return proto.CompactTextString(m) } func (*MatchSet) ProtoMessage() {} -func (*MatchSet) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{150} } +func (*MatchSet) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{166} } func (m *MatchSet) GetType() MatchType { if m != nil { @@ -4620,7 +5374,7 @@ type AsPathLength struct { func (m *AsPathLength) Reset() { *m = AsPathLength{} } func (m *AsPathLength) String() string { return proto.CompactTextString(m) } func (*AsPathLength) ProtoMessage() {} -func (*AsPathLength) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{151} } +func (*AsPathLength) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{167} } func (m *AsPathLength) GetType() AsPathLengthType { if m != nil { @@ -4646,12 +5400,14 @@ type Conditions struct { RpkiResult int32 `protobuf:"varint,7,opt,name=rpki_result,json=rpkiResult" json:"rpki_result,omitempty"` RouteType Conditions_RouteType `protobuf:"varint,8,opt,name=route_type,json=routeType,enum=gobgpapi.Conditions_RouteType" json:"route_type,omitempty"` LargeCommunitySet *MatchSet `protobuf:"bytes,9,opt,name=large_community_set,json=largeCommunitySet" json:"large_community_set,omitempty"` + NextHopInList []string `protobuf:"bytes,10,rep,name=next_hop_in_list,json=nextHopInList" json:"next_hop_in_list,omitempty"` + AfiSafiIn []Family `protobuf:"varint,11,rep,packed,name=afi_safi_in,json=afiSafiIn,enum=gobgpapi.Family" json:"afi_safi_in,omitempty"` } func (m *Conditions) Reset() { *m = Conditions{} } func (m *Conditions) String() string { return proto.CompactTextString(m) } func (*Conditions) ProtoMessage() {} -func (*Conditions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{152} } +func (*Conditions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{168} } func (m *Conditions) GetPrefixSet() *MatchSet { if m != nil { @@ -4716,6 +5472,20 @@ func (m *Conditions) GetLargeCommunitySet() *MatchSet { return nil } +func (m *Conditions) GetNextHopInList() []string { + if m != nil { + return m.NextHopInList + } + return nil +} + +func (m *Conditions) GetAfiSafiIn() []Family { + if m != nil { + return m.AfiSafiIn + } + return nil +} + type CommunityAction struct { Type CommunityActionType `protobuf:"varint,1,opt,name=type,enum=gobgpapi.CommunityActionType" json:"type,omitempty"` Communities []string `protobuf:"bytes,2,rep,name=communities" json:"communities,omitempty"` @@ -4724,7 +5494,7 @@ type CommunityAction struct { func (m *CommunityAction) Reset() { *m = CommunityAction{} } func (m *CommunityAction) String() string { return proto.CompactTextString(m) } func (*CommunityAction) ProtoMessage() {} -func (*CommunityAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{153} } +func (*CommunityAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{169} } func (m *CommunityAction) GetType() CommunityActionType { if m != nil { @@ -4748,7 +5518,7 @@ type MedAction struct { func (m *MedAction) Reset() { *m = MedAction{} } func (m *MedAction) String() string { return proto.CompactTextString(m) } func (*MedAction) ProtoMessage() {} -func (*MedAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{154} } +func (*MedAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{170} } func (m *MedAction) GetType() MedActionType { if m != nil { @@ -4773,7 +5543,7 @@ type AsPrependAction struct { func (m *AsPrependAction) Reset() { *m = AsPrependAction{} } func (m *AsPrependAction) String() string { return proto.CompactTextString(m) } func (*AsPrependAction) ProtoMessage() {} -func (*AsPrependAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{155} } +func (*AsPrependAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{171} } func (m *AsPrependAction) GetAsn() uint32 { if m != nil { @@ -4804,7 +5574,7 @@ type NexthopAction struct { func (m *NexthopAction) Reset() { *m = NexthopAction{} } func (m *NexthopAction) String() string { return proto.CompactTextString(m) } func (*NexthopAction) ProtoMessage() {} -func (*NexthopAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{156} } +func (*NexthopAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{172} } func (m *NexthopAction) GetAddress() string { if m != nil { @@ -4827,7 +5597,7 @@ type LocalPrefAction struct { func (m *LocalPrefAction) Reset() { *m = LocalPrefAction{} } func (m *LocalPrefAction) String() string { return proto.CompactTextString(m) } func (*LocalPrefAction) ProtoMessage() {} -func (*LocalPrefAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{157} } +func (*LocalPrefAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{173} } func (m *LocalPrefAction) GetValue() uint32 { if m != nil { @@ -4850,7 +5620,7 @@ type Actions struct { func (m *Actions) Reset() { *m = Actions{} } func (m *Actions) String() string { return proto.CompactTextString(m) } func (*Actions) ProtoMessage() {} -func (*Actions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{158} } +func (*Actions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{174} } func (m *Actions) GetRouteAction() RouteAction { if m != nil { @@ -4917,7 +5687,7 @@ type Statement struct { func (m *Statement) Reset() { *m = Statement{} } func (m *Statement) String() string { return proto.CompactTextString(m) } func (*Statement) ProtoMessage() {} -func (*Statement) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{159} } +func (*Statement) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{175} } func (m *Statement) GetName() string { if m != nil { @@ -4948,7 +5718,7 @@ type Policy struct { func (m *Policy) Reset() { *m = Policy{} } func (m *Policy) String() string { return proto.CompactTextString(m) } func (*Policy) ProtoMessage() {} -func (*Policy) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{160} } +func (*Policy) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{176} } func (m *Policy) GetName() string { if m != nil { @@ -4975,7 +5745,7 @@ type PolicyAssignment struct { func (m *PolicyAssignment) Reset() { *m = PolicyAssignment{} } func (m *PolicyAssignment) String() string { return proto.CompactTextString(m) } func (*PolicyAssignment) ProtoMessage() {} -func (*PolicyAssignment) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{161} } +func (*PolicyAssignment) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{177} } func (m *PolicyAssignment) GetType() PolicyType { if m != nil { @@ -5012,6 +5782,30 @@ func (m *PolicyAssignment) GetDefault() RouteAction { return RouteAction_NONE } +type RoutingPolicy struct { + DefinedSet []*DefinedSet `protobuf:"bytes,1,rep,name=defined_set,json=definedSet" json:"defined_set,omitempty"` + PolicyDefinition []*Policy `protobuf:"bytes,2,rep,name=policy_definition,json=policyDefinition" json:"policy_definition,omitempty"` +} + +func (m *RoutingPolicy) Reset() { *m = RoutingPolicy{} } +func (m *RoutingPolicy) String() string { return proto.CompactTextString(m) } +func (*RoutingPolicy) ProtoMessage() {} +func (*RoutingPolicy) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{178} } + +func (m *RoutingPolicy) GetDefinedSet() []*DefinedSet { + if m != nil { + return m.DefinedSet + } + return nil +} + +func (m *RoutingPolicy) GetPolicyDefinition() []*Policy { + if m != nil { + return m.PolicyDefinition + } + return nil +} + type Roa struct { As uint32 `protobuf:"varint,1,opt,name=as" json:"as,omitempty"` Prefixlen uint32 `protobuf:"varint,2,opt,name=prefixlen" json:"prefixlen,omitempty"` @@ -5023,7 +5817,7 @@ type Roa struct { func (m *Roa) Reset() { *m = Roa{} } func (m *Roa) String() string { return proto.CompactTextString(m) } func (*Roa) ProtoMessage() {} -func (*Roa) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{162} } +func (*Roa) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{179} } func (m *Roa) GetAs() uint32 { if m != nil { @@ -5067,7 +5861,7 @@ type GetRoaRequest struct { func (m *GetRoaRequest) Reset() { *m = GetRoaRequest{} } func (m *GetRoaRequest) String() string { return proto.CompactTextString(m) } func (*GetRoaRequest) ProtoMessage() {} -func (*GetRoaRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{163} } +func (*GetRoaRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{180} } func (m *GetRoaRequest) GetFamily() uint32 { if m != nil { @@ -5083,7 +5877,7 @@ type GetRoaResponse struct { func (m *GetRoaResponse) Reset() { *m = GetRoaResponse{} } func (m *GetRoaResponse) String() string { return proto.CompactTextString(m) } func (*GetRoaResponse) ProtoMessage() {} -func (*GetRoaResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{164} } +func (*GetRoaResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{181} } func (m *GetRoaResponse) GetRoas() []*Roa { if m != nil { @@ -5093,17 +5887,29 @@ func (m *GetRoaResponse) GetRoas() []*Roa { } type Vrf struct { - Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` - Rd []byte `protobuf:"bytes,2,opt,name=rd,proto3" json:"rd,omitempty"` - ImportRt [][]byte `protobuf:"bytes,3,rep,name=import_rt,json=importRt,proto3" json:"import_rt,omitempty"` - ExportRt [][]byte `protobuf:"bytes,4,rep,name=export_rt,json=exportRt,proto3" json:"export_rt,omitempty"` - Id uint32 `protobuf:"varint,5,opt,name=id" json:"id,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // Route Distinguisher must be one of + // RouteDistinguisherTwoOctetAS, + // RouteDistinguisherIPAddressAS, + // or RouteDistinguisherFourOctetAS. + Rd *google_protobuf.Any `protobuf:"bytes,2,opt,name=rd" json:"rd,omitempty"` + // List of the Import Route Targets. Each must be one of + // TwoOctetAsSpecificExtended, + // IPv4AddressSpecificExtended, + // or FourOctetAsSpecificExtended. + ImportRt []*google_protobuf.Any `protobuf:"bytes,3,rep,name=import_rt,json=importRt" json:"import_rt,omitempty"` + // List of the Export Route Targets. Each must be one of + // TwoOctetAsSpecificExtended, + // IPv4AddressSpecificExtended, + // or FourOctetAsSpecificExtended. + ExportRt []*google_protobuf.Any `protobuf:"bytes,4,rep,name=export_rt,json=exportRt" json:"export_rt,omitempty"` + Id uint32 `protobuf:"varint,5,opt,name=id" json:"id,omitempty"` } func (m *Vrf) Reset() { *m = Vrf{} } func (m *Vrf) String() string { return proto.CompactTextString(m) } func (*Vrf) ProtoMessage() {} -func (*Vrf) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{165} } +func (*Vrf) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{182} } func (m *Vrf) GetName() string { if m != nil { @@ -5112,21 +5918,21 @@ func (m *Vrf) GetName() string { return "" } -func (m *Vrf) GetRd() []byte { +func (m *Vrf) GetRd() *google_protobuf.Any { if m != nil { return m.Rd } return nil } -func (m *Vrf) GetImportRt() [][]byte { +func (m *Vrf) GetImportRt() []*google_protobuf.Any { if m != nil { return m.ImportRt } return nil } -func (m *Vrf) GetExportRt() [][]byte { +func (m *Vrf) GetExportRt() []*google_protobuf.Any { if m != nil { return m.ExportRt } @@ -5140,19 +5946,48 @@ func (m *Vrf) GetId() uint32 { return 0 } +type DefaultRouteDistance struct { + ExternalRouteDistance uint32 `protobuf:"varint,1,opt,name=external_route_distance,json=externalRouteDistance" json:"external_route_distance,omitempty"` + InternalRouteDistance uint32 `protobuf:"varint,2,opt,name=internal_route_distance,json=internalRouteDistance" json:"internal_route_distance,omitempty"` +} + +func (m *DefaultRouteDistance) Reset() { *m = DefaultRouteDistance{} } +func (m *DefaultRouteDistance) String() string { return proto.CompactTextString(m) } +func (*DefaultRouteDistance) ProtoMessage() {} +func (*DefaultRouteDistance) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{183} } + +func (m *DefaultRouteDistance) GetExternalRouteDistance() uint32 { + if m != nil { + return m.ExternalRouteDistance + } + return 0 +} + +func (m *DefaultRouteDistance) GetInternalRouteDistance() uint32 { + if m != nil { + return m.InternalRouteDistance + } + return 0 +} + type Global struct { - As uint32 `protobuf:"varint,1,opt,name=as" json:"as,omitempty"` - RouterId string `protobuf:"bytes,2,opt,name=router_id,json=routerId" json:"router_id,omitempty"` - ListenPort int32 `protobuf:"varint,3,opt,name=listen_port,json=listenPort" json:"listen_port,omitempty"` - ListenAddresses []string `protobuf:"bytes,4,rep,name=listen_addresses,json=listenAddresses" json:"listen_addresses,omitempty"` - Families []uint32 `protobuf:"varint,5,rep,packed,name=families" json:"families,omitempty"` - UseMultiplePaths bool `protobuf:"varint,6,opt,name=use_multiple_paths,json=useMultiplePaths" json:"use_multiple_paths,omitempty"` + As uint32 `protobuf:"varint,1,opt,name=as" json:"as,omitempty"` + RouterId string `protobuf:"bytes,2,opt,name=router_id,json=routerId" json:"router_id,omitempty"` + ListenPort int32 `protobuf:"varint,3,opt,name=listen_port,json=listenPort" json:"listen_port,omitempty"` + ListenAddresses []string `protobuf:"bytes,4,rep,name=listen_addresses,json=listenAddresses" json:"listen_addresses,omitempty"` + Families []uint32 `protobuf:"varint,5,rep,packed,name=families" json:"families,omitempty"` + UseMultiplePaths bool `protobuf:"varint,6,opt,name=use_multiple_paths,json=useMultiplePaths" json:"use_multiple_paths,omitempty"` + RouteSelectionOptions *RouteSelectionOptionsConfig `protobuf:"bytes,7,opt,name=route_selection_options,json=routeSelectionOptions" json:"route_selection_options,omitempty"` + DefaultRouteDistance *DefaultRouteDistance `protobuf:"bytes,8,opt,name=default_route_distance,json=defaultRouteDistance" json:"default_route_distance,omitempty"` + Confederation *Confederation `protobuf:"bytes,9,opt,name=confederation" json:"confederation,omitempty"` + GracefulRestart *GracefulRestart `protobuf:"bytes,10,opt,name=graceful_restart,json=gracefulRestart" json:"graceful_restart,omitempty"` + ApplyPolicy *ApplyPolicy `protobuf:"bytes,11,opt,name=apply_policy,json=applyPolicy" json:"apply_policy,omitempty"` } func (m *Global) Reset() { *m = Global{} } func (m *Global) String() string { return proto.CompactTextString(m) } func (*Global) ProtoMessage() {} -func (*Global) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{166} } +func (*Global) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{184} } func (m *Global) GetAs() uint32 { if m != nil { @@ -5196,6 +6031,73 @@ func (m *Global) GetUseMultiplePaths() bool { return false } +func (m *Global) GetRouteSelectionOptions() *RouteSelectionOptionsConfig { + if m != nil { + return m.RouteSelectionOptions + } + return nil +} + +func (m *Global) GetDefaultRouteDistance() *DefaultRouteDistance { + if m != nil { + return m.DefaultRouteDistance + } + return nil +} + +func (m *Global) GetConfederation() *Confederation { + if m != nil { + return m.Confederation + } + return nil +} + +func (m *Global) GetGracefulRestart() *GracefulRestart { + if m != nil { + return m.GracefulRestart + } + return nil +} + +func (m *Global) GetApplyPolicy() *ApplyPolicy { + if m != nil { + return m.ApplyPolicy + } + return nil +} + +type Confederation struct { + Enabled bool `protobuf:"varint,1,opt,name=enabled" json:"enabled,omitempty"` + Identifier uint32 `protobuf:"varint,2,opt,name=identifier" json:"identifier,omitempty"` + MemberAsList []uint32 `protobuf:"varint,3,rep,packed,name=member_as_list,json=memberAsList" json:"member_as_list,omitempty"` +} + +func (m *Confederation) Reset() { *m = Confederation{} } +func (m *Confederation) String() string { return proto.CompactTextString(m) } +func (*Confederation) ProtoMessage() {} +func (*Confederation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{185} } + +func (m *Confederation) GetEnabled() bool { + if m != nil { + return m.Enabled + } + return false +} + +func (m *Confederation) GetIdentifier() uint32 { + if m != nil { + return m.Identifier + } + return 0 +} + +func (m *Confederation) GetMemberAsList() []uint32 { + if m != nil { + return m.MemberAsList + } + return nil +} + type TableInfo struct { Type Resource `protobuf:"varint,1,opt,name=type,enum=gobgpapi.Resource" json:"type,omitempty"` Name string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` @@ -5208,7 +6110,7 @@ type TableInfo struct { func (m *TableInfo) Reset() { *m = TableInfo{} } func (m *TableInfo) String() string { return proto.CompactTextString(m) } func (*TableInfo) ProtoMessage() {} -func (*TableInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{167} } +func (*TableInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{186} } func (m *TableInfo) GetType() Resource { if m != nil { @@ -5259,7 +6161,7 @@ type GetRibInfoRequest struct { func (m *GetRibInfoRequest) Reset() { *m = GetRibInfoRequest{} } func (m *GetRibInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetRibInfoRequest) ProtoMessage() {} -func (*GetRibInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{168} } +func (*GetRibInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{187} } func (m *GetRibInfoRequest) GetInfo() *TableInfo { if m != nil { @@ -5275,7 +6177,7 @@ type GetRibInfoResponse struct { func (m *GetRibInfoResponse) Reset() { *m = GetRibInfoResponse{} } func (m *GetRibInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetRibInfoResponse) ProtoMessage() {} -func (*GetRibInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{169} } +func (*GetRibInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{188} } func (m *GetRibInfoResponse) GetInfo() *TableInfo { if m != nil { @@ -5284,6 +6186,62 @@ func (m *GetRibInfoResponse) GetInfo() *TableInfo { return nil } +type AddCollectorRequest struct { + Url string `protobuf:"bytes,1,opt,name=url" json:"url,omitempty"` + DbName string `protobuf:"bytes,2,opt,name=db_name,json=dbName" json:"db_name,omitempty"` + TableDumpInterval uint64 `protobuf:"varint,3,opt,name=table_dump_interval,json=tableDumpInterval" json:"table_dump_interval,omitempty"` +} + +func (m *AddCollectorRequest) Reset() { *m = AddCollectorRequest{} } +func (m *AddCollectorRequest) String() string { return proto.CompactTextString(m) } +func (*AddCollectorRequest) ProtoMessage() {} +func (*AddCollectorRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{189} } + +func (m *AddCollectorRequest) GetUrl() string { + if m != nil { + return m.Url + } + return "" +} + +func (m *AddCollectorRequest) GetDbName() string { + if m != nil { + return m.DbName + } + return "" +} + +func (m *AddCollectorRequest) GetTableDumpInterval() uint64 { + if m != nil { + return m.TableDumpInterval + } + return 0 +} + +type AddCollectorResponse struct { +} + +func (m *AddCollectorResponse) Reset() { *m = AddCollectorResponse{} } +func (m *AddCollectorResponse) String() string { return proto.CompactTextString(m) } +func (*AddCollectorResponse) ProtoMessage() {} +func (*AddCollectorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{190} } + +type ShutdownRequest struct { +} + +func (m *ShutdownRequest) Reset() { *m = ShutdownRequest{} } +func (m *ShutdownRequest) String() string { return proto.CompactTextString(m) } +func (*ShutdownRequest) ProtoMessage() {} +func (*ShutdownRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{191} } + +type ShutdownResponse struct { +} + +func (m *ShutdownResponse) Reset() { *m = ShutdownResponse{} } +func (m *ShutdownResponse) String() string { return proto.CompactTextString(m) } +func (*ShutdownResponse) ProtoMessage() {} +func (*ShutdownResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{192} } + func init() { proto.RegisterType((*GetNeighborRequest)(nil), "gobgpapi.GetNeighborRequest") proto.RegisterType((*GetNeighborResponse)(nil), "gobgpapi.GetNeighborResponse") @@ -5296,6 +6254,16 @@ func init() { proto.RegisterType((*AddNeighborResponse)(nil), "gobgpapi.AddNeighborResponse") proto.RegisterType((*DeleteNeighborRequest)(nil), "gobgpapi.DeleteNeighborRequest") proto.RegisterType((*DeleteNeighborResponse)(nil), "gobgpapi.DeleteNeighborResponse") + proto.RegisterType((*UpdateNeighborRequest)(nil), "gobgpapi.UpdateNeighborRequest") + proto.RegisterType((*UpdateNeighborResponse)(nil), "gobgpapi.UpdateNeighborResponse") + proto.RegisterType((*AddPeerGroupRequest)(nil), "gobgpapi.AddPeerGroupRequest") + proto.RegisterType((*AddPeerGroupResponse)(nil), "gobgpapi.AddPeerGroupResponse") + proto.RegisterType((*DeletePeerGroupRequest)(nil), "gobgpapi.DeletePeerGroupRequest") + proto.RegisterType((*DeletePeerGroupResponse)(nil), "gobgpapi.DeletePeerGroupResponse") + proto.RegisterType((*UpdatePeerGroupRequest)(nil), "gobgpapi.UpdatePeerGroupRequest") + proto.RegisterType((*UpdatePeerGroupResponse)(nil), "gobgpapi.UpdatePeerGroupResponse") + proto.RegisterType((*AddDynamicNeighborRequest)(nil), "gobgpapi.AddDynamicNeighborRequest") + proto.RegisterType((*AddDynamicNeighborResponse)(nil), "gobgpapi.AddDynamicNeighborResponse") proto.RegisterType((*ResetNeighborRequest)(nil), "gobgpapi.ResetNeighborRequest") proto.RegisterType((*ResetNeighborResponse)(nil), "gobgpapi.ResetNeighborResponse") proto.RegisterType((*SoftResetNeighborRequest)(nil), "gobgpapi.SoftResetNeighborRequest") @@ -5306,6 +6274,8 @@ func init() { proto.RegisterType((*EnableNeighborResponse)(nil), "gobgpapi.EnableNeighborResponse") proto.RegisterType((*DisableNeighborRequest)(nil), "gobgpapi.DisableNeighborRequest") proto.RegisterType((*DisableNeighborResponse)(nil), "gobgpapi.DisableNeighborResponse") + proto.RegisterType((*UpdatePolicyRequest)(nil), "gobgpapi.UpdatePolicyRequest") + proto.RegisterType((*UpdatePolicyResponse)(nil), "gobgpapi.UpdatePolicyResponse") proto.RegisterType((*EnableMrtRequest)(nil), "gobgpapi.EnableMrtRequest") proto.RegisterType((*EnableMrtResponse)(nil), "gobgpapi.EnableMrtResponse") proto.RegisterType((*DisableMrtRequest)(nil), "gobgpapi.DisableMrtRequest") @@ -5391,9 +6361,13 @@ func init() { proto.RegisterType((*ValidateRibRequest)(nil), "gobgpapi.ValidateRibRequest") proto.RegisterType((*ValidateRibResponse)(nil), "gobgpapi.ValidateRibResponse") proto.RegisterType((*Peer)(nil), "gobgpapi.Peer") + proto.RegisterType((*PeerGroup)(nil), "gobgpapi.PeerGroup") + proto.RegisterType((*DynamicNeighbor)(nil), "gobgpapi.DynamicNeighbor") proto.RegisterType((*ApplyPolicy)(nil), "gobgpapi.ApplyPolicy") proto.RegisterType((*PrefixLimit)(nil), "gobgpapi.PrefixLimit") proto.RegisterType((*PeerConf)(nil), "gobgpapi.PeerConf") + proto.RegisterType((*PeerGroupConf)(nil), "gobgpapi.PeerGroupConf") + proto.RegisterType((*PeerGroupState)(nil), "gobgpapi.PeerGroupState") proto.RegisterType((*EbgpMultihop)(nil), "gobgpapi.EbgpMultihop") proto.RegisterType((*RouteReflector)(nil), "gobgpapi.RouteReflector") proto.RegisterType((*PeerState)(nil), "gobgpapi.PeerState") @@ -5447,14 +6421,21 @@ func init() { proto.RegisterType((*Statement)(nil), "gobgpapi.Statement") proto.RegisterType((*Policy)(nil), "gobgpapi.Policy") proto.RegisterType((*PolicyAssignment)(nil), "gobgpapi.PolicyAssignment") + proto.RegisterType((*RoutingPolicy)(nil), "gobgpapi.RoutingPolicy") proto.RegisterType((*Roa)(nil), "gobgpapi.Roa") proto.RegisterType((*GetRoaRequest)(nil), "gobgpapi.GetRoaRequest") proto.RegisterType((*GetRoaResponse)(nil), "gobgpapi.GetRoaResponse") proto.RegisterType((*Vrf)(nil), "gobgpapi.Vrf") + proto.RegisterType((*DefaultRouteDistance)(nil), "gobgpapi.DefaultRouteDistance") proto.RegisterType((*Global)(nil), "gobgpapi.Global") + proto.RegisterType((*Confederation)(nil), "gobgpapi.Confederation") proto.RegisterType((*TableInfo)(nil), "gobgpapi.TableInfo") proto.RegisterType((*GetRibInfoRequest)(nil), "gobgpapi.GetRibInfoRequest") proto.RegisterType((*GetRibInfoResponse)(nil), "gobgpapi.GetRibInfoResponse") + proto.RegisterType((*AddCollectorRequest)(nil), "gobgpapi.AddCollectorRequest") + proto.RegisterType((*AddCollectorResponse)(nil), "gobgpapi.AddCollectorResponse") + proto.RegisterType((*ShutdownRequest)(nil), "gobgpapi.ShutdownRequest") + proto.RegisterType((*ShutdownResponse)(nil), "gobgpapi.ShutdownResponse") proto.RegisterEnum("gobgpapi.Family", Family_name, Family_value) proto.RegisterEnum("gobgpapi.Resource", Resource_name, Resource_value) proto.RegisterEnum("gobgpapi.TableLookupOption", TableLookupOption_name, TableLookupOption_value) @@ -5470,6 +6451,8 @@ func init() { proto.RegisterEnum("gobgpapi.RPKIValidation_State", RPKIValidation_State_name, RPKIValidation_State_value) proto.RegisterEnum("gobgpapi.RPKIValidation_Reason", RPKIValidation_Reason_name, RPKIValidation_Reason_value) proto.RegisterEnum("gobgpapi.PeerConf_RemovePrivateAs", PeerConf_RemovePrivateAs_name, PeerConf_RemovePrivateAs_value) + proto.RegisterEnum("gobgpapi.PeerGroupConf_RemovePrivateAs", PeerGroupConf_RemovePrivateAs_name, PeerGroupConf_RemovePrivateAs_value) + proto.RegisterEnum("gobgpapi.PeerGroupState_RemovePrivateAs", PeerGroupState_RemovePrivateAs_name, PeerGroupState_RemovePrivateAs_value) proto.RegisterEnum("gobgpapi.PeerState_AdminState", PeerState_AdminState_name, PeerState_AdminState_value) proto.RegisterEnum("gobgpapi.Conditions_RouteType", Conditions_RouteType_name, Conditions_RouteType_value) } @@ -5490,6 +6473,7 @@ type GobgpApiClient interface { GetServer(ctx context.Context, in *GetServerRequest, opts ...grpc.CallOption) (*GetServerResponse, error) AddNeighbor(ctx context.Context, in *AddNeighborRequest, opts ...grpc.CallOption) (*AddNeighborResponse, error) DeleteNeighbor(ctx context.Context, in *DeleteNeighborRequest, opts ...grpc.CallOption) (*DeleteNeighborResponse, error) + UpdateNeighbor(ctx context.Context, in *UpdateNeighborRequest, opts ...grpc.CallOption) (*UpdateNeighborResponse, error) GetNeighbor(ctx context.Context, in *GetNeighborRequest, opts ...grpc.CallOption) (*GetNeighborResponse, error) ResetNeighbor(ctx context.Context, in *ResetNeighborRequest, opts ...grpc.CallOption) (*ResetNeighborResponse, error) SoftResetNeighbor(ctx context.Context, in *SoftResetNeighborRequest, opts ...grpc.CallOption) (*SoftResetNeighborResponse, error) @@ -5532,11 +6516,18 @@ type GobgpApiClient interface { AddPolicy(ctx context.Context, in *AddPolicyRequest, opts ...grpc.CallOption) (*AddPolicyResponse, error) DeletePolicy(ctx context.Context, in *DeletePolicyRequest, opts ...grpc.CallOption) (*DeletePolicyResponse, error) ReplacePolicy(ctx context.Context, in *ReplacePolicyRequest, opts ...grpc.CallOption) (*ReplacePolicyResponse, error) + UpdatePolicy(ctx context.Context, in *UpdatePolicyRequest, opts ...grpc.CallOption) (*UpdatePolicyResponse, error) GetPolicyAssignment(ctx context.Context, in *GetPolicyAssignmentRequest, opts ...grpc.CallOption) (*GetPolicyAssignmentResponse, error) AddPolicyAssignment(ctx context.Context, in *AddPolicyAssignmentRequest, opts ...grpc.CallOption) (*AddPolicyAssignmentResponse, error) DeletePolicyAssignment(ctx context.Context, in *DeletePolicyAssignmentRequest, opts ...grpc.CallOption) (*DeletePolicyAssignmentResponse, error) ReplacePolicyAssignment(ctx context.Context, in *ReplacePolicyAssignmentRequest, opts ...grpc.CallOption) (*ReplacePolicyAssignmentResponse, error) GetRibInfo(ctx context.Context, in *GetRibInfoRequest, opts ...grpc.CallOption) (*GetRibInfoResponse, error) + AddPeerGroup(ctx context.Context, in *AddPeerGroupRequest, opts ...grpc.CallOption) (*AddPeerGroupResponse, error) + DeletePeerGroup(ctx context.Context, in *DeletePeerGroupRequest, opts ...grpc.CallOption) (*DeletePeerGroupResponse, error) + UpdatePeerGroup(ctx context.Context, in *UpdatePeerGroupRequest, opts ...grpc.CallOption) (*UpdatePeerGroupResponse, error) + AddDynamicNeighbor(ctx context.Context, in *AddDynamicNeighborRequest, opts ...grpc.CallOption) (*AddDynamicNeighborResponse, error) + AddCollector(ctx context.Context, in *AddCollectorRequest, opts ...grpc.CallOption) (*AddCollectorResponse, error) + Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error) } type gobgpApiClient struct { @@ -5592,6 +6583,15 @@ func (c *gobgpApiClient) DeleteNeighbor(ctx context.Context, in *DeleteNeighborR return out, nil } +func (c *gobgpApiClient) UpdateNeighbor(ctx context.Context, in *UpdateNeighborRequest, opts ...grpc.CallOption) (*UpdateNeighborResponse, error) { + out := new(UpdateNeighborResponse) + err := grpc.Invoke(ctx, "/gobgpapi.GobgpApi/UpdateNeighbor", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *gobgpApiClient) GetNeighbor(ctx context.Context, in *GetNeighborRequest, opts ...grpc.CallOption) (*GetNeighborResponse, error) { out := new(GetNeighborResponse) err := grpc.Invoke(ctx, "/gobgpapi.GobgpApi/GetNeighbor", in, out, c.cc, opts...) @@ -6064,6 +7064,15 @@ func (c *gobgpApiClient) ReplacePolicy(ctx context.Context, in *ReplacePolicyReq return out, nil } +func (c *gobgpApiClient) UpdatePolicy(ctx context.Context, in *UpdatePolicyRequest, opts ...grpc.CallOption) (*UpdatePolicyResponse, error) { + out := new(UpdatePolicyResponse) + err := grpc.Invoke(ctx, "/gobgpapi.GobgpApi/UpdatePolicy", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *gobgpApiClient) GetPolicyAssignment(ctx context.Context, in *GetPolicyAssignmentRequest, opts ...grpc.CallOption) (*GetPolicyAssignmentResponse, error) { out := new(GetPolicyAssignmentResponse) err := grpc.Invoke(ctx, "/gobgpapi.GobgpApi/GetPolicyAssignment", in, out, c.cc, opts...) @@ -6109,6 +7118,60 @@ func (c *gobgpApiClient) GetRibInfo(ctx context.Context, in *GetRibInfoRequest, return out, nil } +func (c *gobgpApiClient) AddPeerGroup(ctx context.Context, in *AddPeerGroupRequest, opts ...grpc.CallOption) (*AddPeerGroupResponse, error) { + out := new(AddPeerGroupResponse) + err := grpc.Invoke(ctx, "/gobgpapi.GobgpApi/AddPeerGroup", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gobgpApiClient) DeletePeerGroup(ctx context.Context, in *DeletePeerGroupRequest, opts ...grpc.CallOption) (*DeletePeerGroupResponse, error) { + out := new(DeletePeerGroupResponse) + err := grpc.Invoke(ctx, "/gobgpapi.GobgpApi/DeletePeerGroup", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gobgpApiClient) UpdatePeerGroup(ctx context.Context, in *UpdatePeerGroupRequest, opts ...grpc.CallOption) (*UpdatePeerGroupResponse, error) { + out := new(UpdatePeerGroupResponse) + err := grpc.Invoke(ctx, "/gobgpapi.GobgpApi/UpdatePeerGroup", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gobgpApiClient) AddDynamicNeighbor(ctx context.Context, in *AddDynamicNeighborRequest, opts ...grpc.CallOption) (*AddDynamicNeighborResponse, error) { + out := new(AddDynamicNeighborResponse) + err := grpc.Invoke(ctx, "/gobgpapi.GobgpApi/AddDynamicNeighbor", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gobgpApiClient) AddCollector(ctx context.Context, in *AddCollectorRequest, opts ...grpc.CallOption) (*AddCollectorResponse, error) { + out := new(AddCollectorResponse) + err := grpc.Invoke(ctx, "/gobgpapi.GobgpApi/AddCollector", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gobgpApiClient) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error) { + out := new(ShutdownResponse) + err := grpc.Invoke(ctx, "/gobgpapi.GobgpApi/Shutdown", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // Server API for GobgpApi service type GobgpApiServer interface { @@ -6117,6 +7180,7 @@ type GobgpApiServer interface { GetServer(context.Context, *GetServerRequest) (*GetServerResponse, error) AddNeighbor(context.Context, *AddNeighborRequest) (*AddNeighborResponse, error) DeleteNeighbor(context.Context, *DeleteNeighborRequest) (*DeleteNeighborResponse, error) + UpdateNeighbor(context.Context, *UpdateNeighborRequest) (*UpdateNeighborResponse, error) GetNeighbor(context.Context, *GetNeighborRequest) (*GetNeighborResponse, error) ResetNeighbor(context.Context, *ResetNeighborRequest) (*ResetNeighborResponse, error) SoftResetNeighbor(context.Context, *SoftResetNeighborRequest) (*SoftResetNeighborResponse, error) @@ -6159,11 +7223,18 @@ type GobgpApiServer interface { AddPolicy(context.Context, *AddPolicyRequest) (*AddPolicyResponse, error) DeletePolicy(context.Context, *DeletePolicyRequest) (*DeletePolicyResponse, error) ReplacePolicy(context.Context, *ReplacePolicyRequest) (*ReplacePolicyResponse, error) + UpdatePolicy(context.Context, *UpdatePolicyRequest) (*UpdatePolicyResponse, error) GetPolicyAssignment(context.Context, *GetPolicyAssignmentRequest) (*GetPolicyAssignmentResponse, error) AddPolicyAssignment(context.Context, *AddPolicyAssignmentRequest) (*AddPolicyAssignmentResponse, error) DeletePolicyAssignment(context.Context, *DeletePolicyAssignmentRequest) (*DeletePolicyAssignmentResponse, error) ReplacePolicyAssignment(context.Context, *ReplacePolicyAssignmentRequest) (*ReplacePolicyAssignmentResponse, error) GetRibInfo(context.Context, *GetRibInfoRequest) (*GetRibInfoResponse, error) + AddPeerGroup(context.Context, *AddPeerGroupRequest) (*AddPeerGroupResponse, error) + DeletePeerGroup(context.Context, *DeletePeerGroupRequest) (*DeletePeerGroupResponse, error) + UpdatePeerGroup(context.Context, *UpdatePeerGroupRequest) (*UpdatePeerGroupResponse, error) + AddDynamicNeighbor(context.Context, *AddDynamicNeighborRequest) (*AddDynamicNeighborResponse, error) + AddCollector(context.Context, *AddCollectorRequest) (*AddCollectorResponse, error) + Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error) } func RegisterGobgpApiServer(s *grpc.Server, srv GobgpApiServer) { @@ -6260,6 +7331,24 @@ func _GobgpApi_DeleteNeighbor_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _GobgpApi_UpdateNeighbor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateNeighborRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GobgpApiServer).UpdateNeighbor(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gobgpapi.GobgpApi/UpdateNeighbor", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GobgpApiServer).UpdateNeighbor(ctx, req.(*UpdateNeighborRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _GobgpApi_GetNeighbor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetNeighborRequest) if err := dec(in); err != nil { @@ -7033,6 +8122,24 @@ func _GobgpApi_ReplacePolicy_Handler(srv interface{}, ctx context.Context, dec f return interceptor(ctx, in, info, handler) } +func _GobgpApi_UpdatePolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdatePolicyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GobgpApiServer).UpdatePolicy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gobgpapi.GobgpApi/UpdatePolicy", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GobgpApiServer).UpdatePolicy(ctx, req.(*UpdatePolicyRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _GobgpApi_GetPolicyAssignment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetPolicyAssignmentRequest) if err := dec(in); err != nil { @@ -7123,6 +8230,114 @@ func _GobgpApi_GetRibInfo_Handler(srv interface{}, ctx context.Context, dec func return interceptor(ctx, in, info, handler) } +func _GobgpApi_AddPeerGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AddPeerGroupRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GobgpApiServer).AddPeerGroup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gobgpapi.GobgpApi/AddPeerGroup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GobgpApiServer).AddPeerGroup(ctx, req.(*AddPeerGroupRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GobgpApi_DeletePeerGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeletePeerGroupRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GobgpApiServer).DeletePeerGroup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gobgpapi.GobgpApi/DeletePeerGroup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GobgpApiServer).DeletePeerGroup(ctx, req.(*DeletePeerGroupRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GobgpApi_UpdatePeerGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdatePeerGroupRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GobgpApiServer).UpdatePeerGroup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gobgpapi.GobgpApi/UpdatePeerGroup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GobgpApiServer).UpdatePeerGroup(ctx, req.(*UpdatePeerGroupRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GobgpApi_AddDynamicNeighbor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AddDynamicNeighborRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GobgpApiServer).AddDynamicNeighbor(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gobgpapi.GobgpApi/AddDynamicNeighbor", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GobgpApiServer).AddDynamicNeighbor(ctx, req.(*AddDynamicNeighborRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GobgpApi_AddCollector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AddCollectorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GobgpApiServer).AddCollector(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gobgpapi.GobgpApi/AddCollector", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GobgpApiServer).AddCollector(ctx, req.(*AddCollectorRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GobgpApi_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ShutdownRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GobgpApiServer).Shutdown(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gobgpapi.GobgpApi/Shutdown", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GobgpApiServer).Shutdown(ctx, req.(*ShutdownRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _GobgpApi_serviceDesc = grpc.ServiceDesc{ ServiceName: "gobgpapi.GobgpApi", HandlerType: (*GobgpApiServer)(nil), @@ -7147,6 +8362,10 @@ var _GobgpApi_serviceDesc = grpc.ServiceDesc{ MethodName: "DeleteNeighbor", Handler: _GobgpApi_DeleteNeighbor_Handler, }, + { + MethodName: "UpdateNeighbor", + Handler: _GobgpApi_UpdateNeighbor_Handler, + }, { MethodName: "GetNeighbor", Handler: _GobgpApi_GetNeighbor_Handler, @@ -7299,6 +8518,10 @@ var _GobgpApi_serviceDesc = grpc.ServiceDesc{ MethodName: "ReplacePolicy", Handler: _GobgpApi_ReplacePolicy_Handler, }, + { + MethodName: "UpdatePolicy", + Handler: _GobgpApi_UpdatePolicy_Handler, + }, { MethodName: "GetPolicyAssignment", Handler: _GobgpApi_GetPolicyAssignment_Handler, @@ -7319,6 +8542,30 @@ var _GobgpApi_serviceDesc = grpc.ServiceDesc{ MethodName: "GetRibInfo", Handler: _GobgpApi_GetRibInfo_Handler, }, + { + MethodName: "AddPeerGroup", + Handler: _GobgpApi_AddPeerGroup_Handler, + }, + { + MethodName: "DeletePeerGroup", + Handler: _GobgpApi_DeletePeerGroup_Handler, + }, + { + MethodName: "UpdatePeerGroup", + Handler: _GobgpApi_UpdatePeerGroup_Handler, + }, + { + MethodName: "AddDynamicNeighbor", + Handler: _GobgpApi_AddDynamicNeighbor_Handler, + }, + { + MethodName: "AddCollector", + Handler: _GobgpApi_AddCollector_Handler, + }, + { + MethodName: "Shutdown", + Handler: _GobgpApi_Shutdown_Handler, + }, }, Streams: []grpc.StreamDesc{ { @@ -7348,469 +8595,526 @@ var _GobgpApi_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("gobgp.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 7420 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xec, 0x7c, 0x5d, 0x6f, 0x23, 0x47, - 0x76, 0xa8, 0xf8, 0x21, 0x8a, 0x3c, 0x24, 0xc5, 0x56, 0x49, 0x1a, 0x71, 0x24, 0xcf, 0x57, 0xaf, - 0xc7, 0x33, 0x96, 0xed, 0xb1, 0x67, 0x6c, 0xcb, 0x5e, 0xcf, 0xda, 0x6b, 0x8e, 0xc4, 0xd1, 0x70, - 0x4d, 0x89, 0x74, 0x8b, 0x33, 0x1e, 0xef, 0xdd, 0xbd, 0x7d, 0x5b, 0xec, 0x22, 0xd5, 0xd7, 0xcd, - 0xee, 0x76, 0x77, 0x53, 0xd6, 0xe0, 0x02, 0xf7, 0xce, 0xec, 0xdd, 0xdd, 0x7b, 0x81, 0x60, 0x5f, - 0xf2, 0x9a, 0x0d, 0xf2, 0x90, 0xb7, 0x05, 0xf2, 0x10, 0x20, 0x40, 0x80, 0x3c, 0x25, 0x40, 0x76, - 0x11, 0x60, 0x81, 0xbc, 0x24, 0xcf, 0xc9, 0x0f, 0xc8, 0x43, 0x12, 0x20, 0x0f, 0x79, 0xd8, 0x87, - 0xa0, 0x3e, 0xba, 0xbb, 0xfa, 0x83, 0x92, 0xc6, 0x3b, 0x4e, 0x10, 0x20, 0x4f, 0x64, 0x9d, 0x73, - 0xea, 0xd4, 0xa9, 0xaa, 0x53, 0xa7, 0x4e, 0x9d, 0xaa, 0x3e, 0x50, 0x1d, 0xdb, 0x87, 0x63, 0xe7, - 0x96, 0xe3, 0xda, 0xbe, 0x8d, 0xca, 0xb4, 0xa0, 0x39, 0x86, 0xfc, 0x7d, 0x40, 0xbb, 0xd8, 0xdf, - 0xc7, 0xc6, 0xf8, 0xe8, 0xd0, 0x76, 0x15, 0xfc, 0xe5, 0x14, 0x7b, 0x3e, 0xda, 0x04, 0x09, 0x5b, - 0xda, 0xa1, 0x89, 0x5b, 0xfa, 0x31, 0x76, 0x7d, 0xc3, 0xc3, 0x7a, 0x33, 0x77, 0x35, 0x77, 0xb3, - 0xac, 0xa4, 0xe0, 0xa8, 0x09, 0x0b, 0x9a, 0xae, 0xbb, 0xd8, 0xf3, 0x9a, 0xf9, 0xab, 0xb9, 0x9b, - 0x15, 0x25, 0x28, 0xca, 0x77, 0x61, 0x39, 0xc6, 0xdb, 0x73, 0x6c, 0xcb, 0xc3, 0xe8, 0x65, 0x98, - 0x77, 0x30, 0x76, 0xbd, 0x66, 0xee, 0x6a, 0xe1, 0x66, 0xf5, 0xce, 0xe2, 0xad, 0x40, 0x98, 0x5b, - 0x7d, 0x8c, 0x5d, 0x85, 0x21, 0xe5, 0x67, 0x39, 0xa8, 0xb4, 0xdc, 0xf1, 0x74, 0x82, 0x2d, 0xdf, - 0x43, 0xb7, 0xa0, 0xec, 0x62, 0xcf, 0x9e, 0xba, 0x43, 0x4c, 0x05, 0x59, 0xbc, 0x83, 0xa2, 0x6a, - 0x0a, 0xc7, 0x28, 0x21, 0x0d, 0xba, 0x00, 0xa5, 0x91, 0x36, 0x31, 0xcc, 0x27, 0x54, 0xa6, 0xba, - 0xc2, 0x4b, 0x08, 0x41, 0xd1, 0xd2, 0x26, 0xb8, 0x59, 0xa0, 0x92, 0xd2, 0xff, 0xa4, 0x03, 0xc3, - 0xa9, 0xeb, 0x62, 0xcb, 0x6f, 0x16, 0x69, 0x1f, 0x83, 0xa2, 0xfc, 0xbf, 0x60, 0xb1, 0xa5, 0xeb, - 0x7d, 0xcd, 0x3f, 0x0a, 0x06, 0xe6, 0x79, 0xe5, 0x58, 0x85, 0xd2, 0xb1, 0x3b, 0x52, 0x0d, 0x9d, - 0x8f, 0xcd, 0xfc, 0xb1, 0x3b, 0xea, 0xe8, 0x48, 0x86, 0xa2, 0xa3, 0xf9, 0x47, 0x54, 0x8c, 0xf8, - 0x08, 0x90, 0xb6, 0x28, 0x4e, 0xbe, 0x0e, 0x8d, 0xb0, 0x71, 0x3e, 0x72, 0x08, 0x8a, 0xd3, 0xa9, - 0xc1, 0xa6, 0xa2, 0xa6, 0xd0, 0xff, 0xf2, 0x2f, 0x72, 0xb0, 0xb4, 0x83, 0x4d, 0xec, 0xe3, 0x6f, - 0x40, 0xce, 0x68, 0x18, 0x0b, 0xb1, 0x61, 0x0c, 0xe4, 0x2f, 0xce, 0x96, 0x3f, 0x14, 0x76, 0x5e, - 0x10, 0x76, 0x05, 0x90, 0x28, 0x2b, 0xeb, 0x96, 0xfc, 0x3e, 0xa0, 0x96, 0xae, 0x27, 0x75, 0x90, - 0xb4, 0x81, 0xb1, 0x4b, 0xc5, 0x4f, 0x6b, 0x09, 0xc5, 0xc9, 0xab, 0xb0, 0x1c, 0xab, 0xc9, 0x19, - 0xde, 0x85, 0x55, 0xd6, 0xcc, 0xd7, 0xe1, 0xd9, 0x84, 0x0b, 0xc9, 0xca, 0x9c, 0xed, 0x23, 0x58, - 0x51, 0xb0, 0x97, 0x5e, 0x2d, 0xc2, 0x0a, 0xc8, 0xc5, 0x56, 0x00, 0x7a, 0x19, 0xea, 0x43, 0x7b, - 0x32, 0x99, 0x5a, 0xc6, 0x50, 0xf3, 0x0d, 0xdb, 0xe2, 0xa3, 0x1b, 0x07, 0xca, 0x6b, 0xb0, 0x9a, - 0xe0, 0xcb, 0x1b, 0xfc, 0xb3, 0x1c, 0x34, 0x0f, 0xec, 0x91, 0xff, 0x9c, 0xad, 0x1e, 0x40, 0x45, - 0x37, 0x5c, 0x3c, 0x0c, 0x5b, 0x5c, 0xbc, 0xf3, 0x6e, 0xd4, 0xd5, 0x59, 0x0c, 0x23, 0xc4, 0x4e, - 0x50, 0x59, 0x89, 0xf8, 0xc8, 0x6f, 0x02, 0x4a, 0x13, 0xa0, 0x12, 0xe4, 0x3b, 0xfb, 0xd2, 0x1c, - 0x5a, 0x80, 0x42, 0xef, 0xe1, 0x40, 0xca, 0xa1, 0x32, 0x14, 0xef, 0xf5, 0x06, 0x0f, 0xa4, 0xbc, - 0xbc, 0x01, 0x17, 0x33, 0x9a, 0xe2, 0x3d, 0xfb, 0x1c, 0xd6, 0x0e, 0x8e, 0xa6, 0xbe, 0x6e, 0x7f, - 0x65, 0xbd, 0xe8, 0xd1, 0x5c, 0x87, 0x66, 0x9a, 0x35, 0x6f, 0xf6, 0x36, 0xac, 0xb6, 0xa9, 0xfd, - 0x3a, 0x77, 0xa3, 0x44, 0x1d, 0x92, 0x55, 0x38, 0xb3, 0xc7, 0x70, 0x61, 0xc7, 0xf0, 0x9e, 0x8b, - 0xdb, 0x39, 0xbb, 0x70, 0x11, 0xd6, 0x52, 0x9c, 0x79, 0xa3, 0x63, 0x90, 0x98, 0x38, 0x7b, 0xae, - 0x1f, 0x34, 0xb7, 0x01, 0x15, 0x7d, 0x3a, 0x71, 0x54, 0xff, 0x89, 0xc3, 0x56, 0xfb, 0xbc, 0x52, - 0x26, 0x80, 0xc1, 0x13, 0x07, 0xa3, 0x75, 0x28, 0x8f, 0x0c, 0x13, 0x53, 0xab, 0xc7, 0x1a, 0x0b, - 0xcb, 0x04, 0x67, 0x58, 0x3e, 0x76, 0x8f, 0x35, 0x93, 0x2e, 0xf0, 0xa2, 0x12, 0x96, 0xe5, 0x65, - 0x58, 0x12, 0x1a, 0xe2, 0xad, 0x2f, 0xc3, 0x12, 0x17, 0x2c, 0x6a, 0x9e, 0x2e, 0x6a, 0x01, 0xc8, - 0x49, 0xff, 0x0f, 0x48, 0x1d, 0xeb, 0x7f, 0xe2, 0xa1, 0x2f, 0x08, 0xfa, 0x82, 0xac, 0x12, 0xd9, - 0x40, 0x34, 0xff, 0xc8, 0x6b, 0x16, 0x52, 0x1b, 0x08, 0x31, 0x2b, 0x0c, 0x49, 0x64, 0x15, 0x04, - 0xe0, 0x52, 0xfd, 0x79, 0x0e, 0xea, 0x2d, 0x5d, 0xbf, 0x37, 0x71, 0xce, 0x9e, 0x2b, 0x04, 0x45, - 0xc7, 0x76, 0x7d, 0xbe, 0x83, 0xd0, 0xff, 0xe8, 0x3b, 0x50, 0xa4, 0xa3, 0x5c, 0xa0, 0xd2, 0xdf, - 0x8c, 0x5a, 0x8e, 0x31, 0xbd, 0xb5, 0x67, 0x5b, 0x86, 0x6f, 0xbb, 0x86, 0x35, 0xee, 0xdb, 0xa6, - 0x31, 0x7c, 0xa2, 0xd0, 0x5a, 0xf2, 0x36, 0x48, 0x49, 0x0c, 0x59, 0x39, 0x7d, 0xa5, 0x2d, 0xcd, - 0x91, 0x95, 0xd3, 0xef, 0x1d, 0xc4, 0xd6, 0x10, 0xaa, 0xc0, 0x7c, 0xb7, 0xb7, 0xdd, 0xea, 0x4a, - 0x05, 0x42, 0xd7, 0xea, 0x76, 0xa5, 0xa2, 0x2c, 0xd1, 0x4d, 0x89, 0x36, 0xc6, 0x3b, 0xf5, 0x31, - 0x48, 0xcc, 0x62, 0x7d, 0xdd, 0x6e, 0xd1, 0x79, 0x8d, 0x38, 0x70, 0xb6, 0x03, 0x58, 0xe2, 0xd2, - 0x2a, 0xc6, 0x61, 0xc0, 0xf7, 0x3a, 0xcc, 0xfb, 0x64, 0xaa, 0xb9, 0x09, 0x6d, 0x44, 0x23, 0x30, - 0x20, 0x60, 0x85, 0x61, 0xc5, 0x3d, 0x35, 0x1f, 0xdf, 0x53, 0xdb, 0x50, 0x56, 0xfa, 0x9f, 0x74, - 0xb6, 0x6d, 0x6b, 0x74, 0x8a, 0x90, 0x57, 0xa0, 0xea, 0xe2, 0x89, 0xed, 0x63, 0x35, 0x94, 0xb5, - 0xa2, 0x00, 0x03, 0xf5, 0x89, 0xc4, 0x3f, 0x2f, 0x42, 0x85, 0xf0, 0x39, 0xf0, 0x35, 0x9f, 0x6e, - 0xf7, 0x53, 0xc7, 0x37, 0x26, 0x4c, 0xac, 0x82, 0xc2, 0x4b, 0x44, 0xc1, 0x89, 0x1d, 0xa0, 0x98, - 0x3c, 0xc5, 0x84, 0x65, 0xb4, 0x08, 0xf9, 0xa9, 0x43, 0x27, 0xb2, 0xac, 0xe4, 0xa7, 0x0e, 0x6b, - 0x72, 0x68, 0xbb, 0xba, 0x6a, 0x38, 0xc7, 0xef, 0xd0, 0xad, 0xad, 0x4e, 0x9a, 0x24, 0xa0, 0x8e, - 0x73, 0xfc, 0x4e, 0x9c, 0x60, 0x8b, 0xee, 0x6b, 0x22, 0xc1, 0x16, 0x21, 0x70, 0x5c, 0x3c, 0x32, - 0x4e, 0x18, 0x87, 0x12, 0x23, 0x60, 0xa0, 0x80, 0x43, 0x44, 0xb0, 0xd5, 0x5c, 0x48, 0x10, 0x6c, - 0x91, 0x7e, 0x78, 0xd8, 0x35, 0x34, 0xb3, 0x59, 0x66, 0xfb, 0x2d, 0x2b, 0xa1, 0x6f, 0x41, 0xdd, - 0xc5, 0x43, 0x6c, 0x1c, 0x63, 0x2e, 0x5d, 0x85, 0x76, 0xa6, 0x16, 0x00, 0x29, 0xf7, 0x04, 0xd1, - 0x56, 0x13, 0x52, 0x44, 0x5b, 0x84, 0x88, 0xf1, 0x54, 0x2d, 0xdb, 0x37, 0x46, 0x4f, 0x9a, 0x55, - 0x46, 0xc4, 0x80, 0xfb, 0x14, 0x46, 0xe4, 0x1c, 0x6a, 0xc3, 0x23, 0xac, 0xba, 0xc4, 0x78, 0x37, - 0x6b, 0x94, 0x04, 0x28, 0x88, 0x9a, 0x73, 0x74, 0x1d, 0x16, 0x43, 0x02, 0xaa, 0x2c, 0xcd, 0x3a, - 0xa5, 0xa9, 0x07, 0x34, 0xcc, 0x5f, 0xb9, 0x0c, 0x55, 0x6c, 0xe9, 0xaa, 0x3d, 0x52, 0x75, 0xcd, - 0xd7, 0x9a, 0x8b, 0x94, 0xa6, 0x82, 0x2d, 0xbd, 0x37, 0xda, 0xd1, 0x7c, 0x0d, 0xad, 0xc0, 0x3c, - 0x76, 0x5d, 0xdb, 0x6d, 0x36, 0x28, 0x86, 0x15, 0xd0, 0x35, 0xe0, 0xd2, 0xa8, 0x5f, 0x4e, 0xb1, - 0xfb, 0xa4, 0x29, 0x51, 0x64, 0x95, 0xc1, 0x3e, 0x25, 0x20, 0x36, 0x15, 0x1e, 0xf6, 0x39, 0xc5, - 0x12, 0x13, 0x90, 0x82, 0x28, 0x81, 0xfc, 0x39, 0x14, 0x15, 0xe7, 0x0b, 0x03, 0xbd, 0x02, 0xc5, - 0xa1, 0x6d, 0x8d, 0xb8, 0xb6, 0x8a, 0xd6, 0x86, 0xeb, 0xa0, 0x42, 0xf1, 0xe8, 0x55, 0x98, 0xf7, - 0x88, 0x26, 0x51, 0x2d, 0xa9, 0xde, 0x59, 0x8e, 0x13, 0x52, 0x25, 0x53, 0x18, 0x85, 0x7c, 0x13, - 0x16, 0x77, 0xb1, 0x4f, 0xb8, 0x07, 0x6b, 0x22, 0xf2, 0x92, 0x72, 0xa2, 0x97, 0x24, 0xdf, 0x85, - 0x46, 0x48, 0xc9, 0x47, 0xe4, 0x26, 0x2c, 0x78, 0xd8, 0x3d, 0xce, 0xf4, 0x7e, 0x29, 0x61, 0x80, - 0x96, 0xbf, 0x4f, 0x97, 0xb9, 0xd8, 0xcc, 0xf3, 0x59, 0xaa, 0x75, 0x28, 0x9b, 0xc6, 0x08, 0x53, - 0xd5, 0x2f, 0x30, 0xd5, 0x0f, 0xca, 0xf2, 0x12, 0x75, 0x2d, 0x45, 0xc1, 0xe4, 0x56, 0x60, 0x01, - 0xbe, 0x76, 0x8b, 0x91, 0x73, 0x17, 0x63, 0xfc, 0x46, 0xb0, 0x8f, 0x9c, 0x8b, 0x31, 0x61, 0x22, - 0x92, 0x73, 0x26, 0xb7, 0xc2, 0x2d, 0xe6, 0x7c, 0x5c, 0x56, 0x61, 0x39, 0x46, 0xcf, 0xd9, 0xbc, - 0x0e, 0x12, 0xd5, 0xdf, 0xf3, 0x31, 0x59, 0x86, 0x25, 0x81, 0x9a, 0xb3, 0x78, 0x0b, 0x56, 0x42, - 0xaf, 0xe6, 0x7c, 0x6c, 0xd6, 0x60, 0x35, 0x51, 0x83, 0xb3, 0xfa, 0x75, 0x2e, 0xe8, 0xeb, 0xf7, - 0xf1, 0xa1, 0xab, 0x05, 0x9c, 0x24, 0x28, 0x4c, 0x5d, 0x93, 0x73, 0x21, 0x7f, 0xa9, 0xb6, 0xdb, - 0x53, 0x1f, 0xd3, 0x0d, 0x9e, 0x9c, 0xb2, 0x0a, 0xd4, 0x18, 0x12, 0x10, 0xd9, 0xe2, 0x3d, 0xd2, - 0x38, 0xd1, 0x19, 0xe2, 0x4f, 0x30, 0x3f, 0x3d, 0x28, 0xa2, 0x77, 0xe0, 0x82, 0x85, 0x4f, 0xfc, - 0x23, 0xdb, 0x51, 0x7d, 0xd7, 0x18, 0x8f, 0xb1, 0xab, 0xb2, 0x03, 0x1c, 0x3f, 0xea, 0xac, 0x70, - 0xec, 0x80, 0x21, 0x99, 0x38, 0xe8, 0x0e, 0xac, 0x26, 0x6b, 0xe9, 0xd8, 0xd4, 0x9e, 0x70, 0x9b, - 0xb7, 0x1c, 0xaf, 0xb4, 0x43, 0x50, 0x64, 0xc8, 0x63, 0x9d, 0xe1, 0x9d, 0x6c, 0x40, 0x7d, 0x17, - 0xfb, 0x8f, 0xdc, 0x51, 0xe0, 0x2d, 0xbc, 0x4d, 0x97, 0x0f, 0x05, 0xf0, 0x35, 0x71, 0x0d, 0x8a, - 0xc7, 0xee, 0x28, 0x58, 0x10, 0xf5, 0x68, 0x41, 0x10, 0x22, 0x8a, 0x92, 0xdf, 0xa2, 0xbb, 0x76, - 0xc4, 0x05, 0x5d, 0x81, 0xc2, 0xb1, 0x1b, 0x2c, 0xeb, 0x44, 0x15, 0x82, 0xe1, 0xbb, 0xa4, 0xd0, - 0x8c, 0xfc, 0x76, 0xb0, 0x4b, 0x3e, 0x0f, 0x9b, 0x70, 0x63, 0x14, 0x39, 0x3d, 0x84, 0x95, 0x5d, - 0xec, 0xef, 0xe0, 0x91, 0x61, 0x61, 0xfd, 0x00, 0x87, 0xee, 0xcd, 0xab, 0xdc, 0x39, 0x60, 0xae, - 0xcd, 0x6a, 0xc4, 0x8e, 0x93, 0x92, 0xc9, 0x62, 0x9e, 0x40, 0x78, 0x0e, 0xcd, 0x47, 0xe7, 0x50, - 0xb9, 0x05, 0xab, 0x09, 0xb6, 0xa1, 0xd1, 0x28, 0x7a, 0xd8, 0x0f, 0x06, 0x68, 0x25, 0xc5, 0x97, - 0xd0, 0x52, 0x0a, 0xf9, 0x23, 0x58, 0x69, 0xe9, 0x7a, 0x5a, 0xb2, 0x57, 0xa0, 0x40, 0x0c, 0x39, - 0xeb, 0x67, 0x36, 0x03, 0x42, 0x40, 0x74, 0x35, 0x51, 0x9f, 0x77, 0xf9, 0x00, 0xd6, 0xd8, 0x38, - 0x7c, 0x6d, 0xde, 0x44, 0xaf, 0x35, 0xd3, 0xe4, 0xee, 0x00, 0xf9, 0x4b, 0x3c, 0xf5, 0x34, 0x53, - 0xde, 0xe0, 0x3d, 0x68, 0x2a, 0xd8, 0x31, 0xb5, 0xe1, 0xd7, 0x6f, 0x91, 0x9c, 0x40, 0x32, 0x78, - 0xf0, 0x06, 0x56, 0x69, 0x70, 0x82, 0x5a, 0xf6, 0x09, 0xb6, 0x42, 0x67, 0xf6, 0x13, 0x3a, 0xb7, - 0x02, 0x98, 0xcf, 0xc1, 0xdb, 0x00, 0x5e, 0x00, 0x0c, 0x66, 0x42, 0xd8, 0x25, 0xa2, 0x0a, 0x02, - 0x99, 0xfc, 0x80, 0x1e, 0x4f, 0x93, 0x6d, 0xa0, 0xdb, 0x50, 0x09, 0x89, 0x78, 0x2f, 0x32, 0x59, - 0x45, 0x54, 0xf2, 0x05, 0x3a, 0xb1, 0x29, 0xb1, 0xe4, 0x1f, 0x06, 0x87, 0xd5, 0x17, 0xd0, 0x48, - 0xc6, 0x0c, 0x5d, 0x0c, 0xa6, 0x3d, 0xdd, 0x72, 0x17, 0xd6, 0xf8, 0xe0, 0xbe, 0x88, 0xfe, 0xad, - 0x87, 0xd3, 0x9d, 0x6e, 0x09, 0x81, 0xb4, 0x8b, 0x7d, 0xee, 0x48, 0xf3, 0x69, 0x6a, 0xc1, 0x92, - 0x00, 0xe3, 0x73, 0xf4, 0x3a, 0x94, 0x1d, 0x02, 0x31, 0x70, 0x30, 0x43, 0x92, 0x70, 0x34, 0x60, - 0xb4, 0x21, 0x85, 0x7c, 0x02, 0x52, 0x4b, 0xd7, 0x63, 0x6c, 0xd1, 0x4d, 0x28, 0x51, 0xfc, 0x13, - 0x2e, 0x76, 0xba, 0x3e, 0xc7, 0xa3, 0x0f, 0xe0, 0xa2, 0x8b, 0x47, 0xc4, 0x9c, 0x9e, 0x18, 0x9e, - 0x6f, 0x58, 0x63, 0x55, 0x50, 0x0f, 0x36, 0x82, 0x6b, 0x94, 0xa0, 0xcd, 0xf1, 0x07, 0x91, 0x5a, - 0x2c, 0xc3, 0x92, 0xd0, 0x32, 0xef, 0xe5, 0x8f, 0x72, 0xb0, 0xcc, 0x63, 0x23, 0x5f, 0x53, 0xa4, - 0x37, 0x61, 0xd9, 0x21, 0x2e, 0x90, 0x7b, 0x8c, 0xd3, 0xc2, 0xa0, 0x00, 0x15, 0xc9, 0x11, 0xcc, - 0x77, 0x21, 0x9a, 0xef, 0x0b, 0xb0, 0x12, 0x97, 0x81, 0x0b, 0xf7, 0x47, 0x39, 0x58, 0xe1, 0xf3, - 0xf3, 0x1f, 0x30, 0x60, 0xb3, 0x7a, 0x56, 0x98, 0xd5, 0x33, 0x16, 0x51, 0x89, 0x89, 0x1b, 0x9e, - 0xd9, 0xd7, 0x43, 0xbd, 0x69, 0x79, 0x9e, 0x31, 0xb6, 0x44, 0xc5, 0xfd, 0x00, 0x40, 0x0b, 0x81, - 0xbc, 0x47, 0xeb, 0xc9, 0x1e, 0x09, 0xd5, 0x04, 0x6a, 0xf9, 0x73, 0xd8, 0xc8, 0xe4, 0xcc, 0x75, - 0xf3, 0xb7, 0x61, 0xfd, 0x18, 0xd6, 0x43, 0x7d, 0x79, 0xb1, 0x42, 0x5f, 0x82, 0x8d, 0x4c, 0xce, - 0x7c, 0xb4, 0x26, 0x70, 0x49, 0x54, 0x87, 0x17, 0xda, 0x76, 0x86, 0xb5, 0xb9, 0x0a, 0x97, 0x67, - 0x35, 0xc7, 0x05, 0xfa, 0x01, 0x5c, 0x8e, 0xcd, 0xeb, 0x8b, 0x1d, 0x8d, 0x6b, 0x70, 0x65, 0x26, - 0xf7, 0x98, 0x2d, 0x3a, 0xa0, 0x3e, 0x7a, 0x60, 0x8b, 0x3e, 0xa4, 0xb6, 0x28, 0x80, 0x85, 0x7b, - 0x76, 0x69, 0x6c, 0xda, 0x87, 0x9a, 0x99, 0x5e, 0x18, 0xbb, 0x14, 0xae, 0x70, 0xbc, 0xfc, 0x11, - 0xa0, 0x03, 0x5f, 0x73, 0xe3, 0x4c, 0x9f, 0xa3, 0xfe, 0x2a, 0x2c, 0xc7, 0xea, 0x47, 0xa1, 0x9a, - 0x03, 0xdf, 0x76, 0xe2, 0xa2, 0xae, 0x90, 0xb6, 0x22, 0x20, 0x27, 0xfd, 0xc3, 0x02, 0x2c, 0x92, - 0x63, 0xce, 0x23, 0xcd, 0x34, 0x74, 0x1a, 0x81, 0x42, 0xef, 0x04, 0xe7, 0x21, 0xe6, 0xcb, 0x5c, - 0x8e, 0x9f, 0x87, 0x22, 0xc2, 0x5b, 0xe2, 0xd1, 0x08, 0xbd, 0x07, 0x25, 0x17, 0x6b, 0x5e, 0x18, - 0x75, 0xbc, 0x32, 0xb3, 0x9a, 0x42, 0xc9, 0x14, 0x4e, 0x8e, 0x6e, 0xc0, 0xc2, 0x44, 0xf3, 0x87, - 0x47, 0x58, 0xe7, 0x31, 0x1d, 0xc1, 0x17, 0x53, 0x6c, 0x4d, 0x09, 0xb0, 0xe8, 0x2d, 0xa8, 0x4d, - 0x2d, 0x5e, 0x50, 0x35, 0xaf, 0x59, 0xcc, 0xa2, 0xae, 0x86, 0x24, 0x2d, 0x0f, 0xbd, 0x0f, 0x52, - 0x54, 0xc3, 0xc4, 0xd6, 0xd8, 0x3f, 0x6a, 0xce, 0x67, 0xd5, 0x6a, 0x84, 0x64, 0x5d, 0x4a, 0x25, - 0xf7, 0x61, 0x9e, 0x45, 0x17, 0x16, 0x01, 0x0e, 0x06, 0xad, 0x41, 0x5b, 0xdd, 0xef, 0xed, 0xb7, - 0xa5, 0x39, 0xb4, 0x0c, 0x8d, 0xa0, 0x3c, 0x50, 0xef, 0xf7, 0x1e, 0xee, 0xef, 0x48, 0x39, 0xd4, - 0x80, 0x2a, 0x03, 0x3e, 0x6a, 0x75, 0x3b, 0x3b, 0x52, 0x1e, 0x2d, 0x41, 0x9d, 0x01, 0x3a, 0xfb, - 0x0c, 0x54, 0x90, 0xef, 0x42, 0x89, 0x75, 0x9c, 0x50, 0x2b, 0xed, 0xd6, 0x41, 0x6f, 0x10, 0xf0, - 0xac, 0x43, 0x85, 0x02, 0xf6, 0xd5, 0xd6, 0x81, 0x94, 0x23, 0x95, 0x79, 0xb1, 0xdb, 0xde, 0xdf, - 0xa5, 0xf1, 0xd4, 0x7f, 0x2a, 0x42, 0xb1, 0xcf, 0x03, 0xeb, 0x96, 0xe9, 0x1a, 0xc1, 0x2d, 0x00, - 0xf9, 0x4f, 0x8e, 0xa0, 0x8e, 0xe6, 0xfb, 0x2e, 0x3b, 0x1d, 0xd4, 0x14, 0x5e, 0xa2, 0x8b, 0x6c, - 0x1c, 0x1c, 0x00, 0xc9, 0x5f, 0x52, 0xfb, 0x10, 0x7b, 0xc1, 0x55, 0x07, 0xfd, 0x4f, 0x0e, 0x18, - 0x86, 0xa7, 0x7e, 0x65, 0xf8, 0x47, 0xba, 0xab, 0x7d, 0x45, 0xbd, 0xfc, 0xb2, 0x02, 0x86, 0xf7, - 0x19, 0x87, 0xa0, 0xcb, 0x00, 0xc7, 0xe1, 0xe4, 0xd1, 0xc0, 0xc6, 0xbc, 0x22, 0x40, 0x50, 0x1b, - 0x96, 0xa2, 0x92, 0xaa, 0x63, 0x5f, 0x33, 0x4c, 0x1a, 0xde, 0xa8, 0xde, 0x69, 0xce, 0xd2, 0x01, - 0x45, 0x8a, 0xaa, 0xec, 0xd0, 0x1a, 0xe8, 0x2d, 0x58, 0xb1, 0x6c, 0xd5, 0x98, 0x38, 0x64, 0x8b, - 0xf6, 0x23, 0x81, 0xca, 0xcc, 0xd0, 0x5b, 0x76, 0x87, 0xa3, 0x42, 0xc1, 0xa2, 0xa3, 0x77, 0x25, - 0x76, 0x41, 0x71, 0x09, 0x80, 0xc5, 0x10, 0x55, 0xcd, 0xb3, 0x68, 0x20, 0xa4, 0xae, 0x54, 0x18, - 0xa4, 0xe5, 0x59, 0x68, 0x03, 0x78, 0x41, 0x35, 0x74, 0x1a, 0x01, 0xa9, 0x28, 0x65, 0x06, 0xe8, - 0xe8, 0x3c, 0x62, 0xea, 0x63, 0x17, 0xeb, 0x34, 0xf4, 0x51, 0x56, 0xc2, 0x32, 0x5a, 0xa1, 0xeb, - 0xc2, 0x64, 0xf1, 0x8e, 0xb2, 0xc2, 0x0a, 0xe8, 0x26, 0x48, 0x86, 0xa7, 0x8e, 0x5c, 0x7b, 0xa2, - 0xe2, 0x13, 0x1f, 0xbb, 0x96, 0x66, 0xd2, 0x60, 0x47, 0x59, 0x59, 0x34, 0xbc, 0xfb, 0xae, 0x3d, - 0x69, 0x73, 0x28, 0x19, 0x69, 0x8b, 0x87, 0x74, 0x55, 0xc3, 0xa1, 0x71, 0x8f, 0x8a, 0x02, 0x01, - 0xa8, 0xe3, 0x84, 0xb7, 0x26, 0x52, 0x74, 0x6b, 0x82, 0x5e, 0x07, 0x64, 0x78, 0x6a, 0x70, 0x22, - 0x33, 0x2c, 0x3a, 0x6e, 0x34, 0xe8, 0x51, 0x56, 0x24, 0xc3, 0xdb, 0x67, 0x88, 0x0e, 0x83, 0x93, - 0xb9, 0x32, 0x74, 0x6c, 0xf9, 0xc6, 0xc8, 0xc0, 0x6e, 0x13, 0xb1, 0x18, 0x53, 0x04, 0x41, 0xaf, - 0x82, 0x64, 0xda, 0x43, 0xcd, 0x54, 0x05, 0xaa, 0x65, 0x4a, 0xd5, 0xa0, 0xf0, 0x4e, 0x08, 0x96, - 0xff, 0x20, 0x07, 0xd5, 0x1d, 0x4c, 0x76, 0x63, 0x36, 0xcd, 0x44, 0xcb, 0x68, 0xb0, 0x8a, 0x9f, - 0x4e, 0x79, 0x29, 0x0a, 0xc8, 0xe6, 0x4f, 0x09, 0xc8, 0xa2, 0x1b, 0xd0, 0x30, 0x6d, 0x8b, 0x1c, - 0x26, 0x59, 0x35, 0x1c, 0xec, 0xe0, 0x8b, 0x0c, 0xdc, 0xe7, 0x50, 0x22, 0xa1, 0x77, 0x64, 0xbb, - 0xbe, 0x48, 0xc9, 0xd4, 0xb5, 0xc1, 0xe1, 0x01, 0xa9, 0xfc, 0xa7, 0x39, 0x98, 0xa7, 0x81, 0x47, - 0xf4, 0x4a, 0xec, 0xf0, 0x95, 0x15, 0x57, 0x9e, 0x79, 0xf2, 0x9a, 0x79, 0xcd, 0xf5, 0x6d, 0xa8, - 0xe9, 0x51, 0xf7, 0x03, 0x6b, 0x13, 0x3b, 0xd8, 0x85, 0x58, 0x25, 0x46, 0x4a, 0x43, 0x7d, 0xb6, - 0xe7, 0xab, 0xdc, 0x3b, 0xe2, 0x4b, 0x8a, 0x80, 0xd8, 0xde, 0x22, 0x6f, 0xd1, 0x83, 0xf1, 0x73, - 0x47, 0x56, 0xe5, 0xf7, 0x58, 0xf8, 0x89, 0xd4, 0xe3, 0x5b, 0xcd, 0x39, 0x2b, 0x4e, 0x60, 0x89, - 0x96, 0xbb, 0xb6, 0xfd, 0xc5, 0xd4, 0x61, 0x23, 0x38, 0x73, 0x46, 0x3f, 0x86, 0xba, 0x49, 0xe9, - 0x54, 0xdb, 0x11, 0xae, 0x91, 0x36, 0x12, 0xbc, 0x19, 0xaf, 0x9e, 0xc3, 0x06, 0xc0, 0x14, 0x4a, - 0xf2, 0xef, 0xe7, 0xa8, 0xa0, 0xe2, 0xa5, 0xe4, 0x37, 0x31, 0x45, 0xef, 0x41, 0x59, 0xd0, 0x11, - 0x32, 0x3d, 0xd9, 0x32, 0xb2, 0xfe, 0x2a, 0x21, 0xb1, 0x6c, 0x02, 0xe2, 0xb6, 0x08, 0x0b, 0x93, - 0x70, 0x5e, 0x11, 0x67, 0xdd, 0x2f, 0x47, 0xe3, 0x59, 0x10, 0xc7, 0x93, 0x6c, 0xd2, 0xb1, 0xd6, - 0xf8, 0xce, 0xfb, 0x0f, 0xc4, 0xa6, 0x63, 0xec, 0x52, 0x9b, 0x43, 0x38, 0x04, 0x47, 0x97, 0xba, - 0x12, 0x96, 0xd1, 0xfb, 0x50, 0xd3, 0x1c, 0xc7, 0x7c, 0x12, 0xe8, 0x12, 0x0b, 0x51, 0x0a, 0x5a, - 0xd8, 0x22, 0x58, 0xee, 0xe8, 0x56, 0xb5, 0xa8, 0x10, 0x46, 0x3f, 0x0b, 0xc9, 0xe8, 0x27, 0x69, - 0x53, 0x88, 0x7e, 0xde, 0x85, 0x3a, 0x3e, 0x1c, 0x3b, 0xea, 0x64, 0x6a, 0xfa, 0xc6, 0x91, 0xed, - 0xf0, 0x7b, 0xdd, 0x0b, 0x51, 0x85, 0xf6, 0xe1, 0xd8, 0xd9, 0xe3, 0x58, 0xa5, 0x86, 0x85, 0x12, - 0x6a, 0x41, 0x83, 0x45, 0xa7, 0x5c, 0x3c, 0x32, 0xf1, 0xd0, 0xb7, 0x5d, 0xaa, 0xed, 0x71, 0xcb, - 0x4f, 0x08, 0x94, 0x00, 0xaf, 0x2c, 0xba, 0xb1, 0x32, 0xba, 0x01, 0x45, 0xc3, 0x1a, 0xd9, 0x74, - 0x63, 0x89, 0x9d, 0x15, 0x89, 0x9c, 0xcc, 0xc3, 0xa0, 0x04, 0xc4, 0x2b, 0xf2, 0x8d, 0x09, 0x76, - 0x3d, 0xbe, 0xb9, 0x08, 0x5e, 0xd1, 0x80, 0xc2, 0x15, 0x8e, 0x27, 0x67, 0x50, 0xdf, 0xd5, 0x2c, - 0x8f, 0x46, 0x29, 0xcb, 0x49, 0xbe, 0x83, 0x00, 0xa5, 0x44, 0x54, 0x64, 0x9c, 0x59, 0x47, 0x58, - 0x08, 0x96, 0xee, 0x28, 0xb1, 0x71, 0xa6, 0xbd, 0xe0, 0xbe, 0x13, 0x8b, 0xc8, 0xb1, 0x02, 0xda, - 0x01, 0x69, 0xec, 0x6a, 0x43, 0x3c, 0x9a, 0x9a, 0xaa, 0x8b, 0x3d, 0xe2, 0x8d, 0xd1, 0x3d, 0xa7, - 0x7a, 0xe7, 0xa2, 0xe0, 0xb6, 0x71, 0x0a, 0x85, 0x11, 0x28, 0x8d, 0x71, 0x1c, 0x80, 0x6e, 0x41, - 0x45, 0x1b, 0x19, 0xaa, 0xa7, 0x8d, 0x0c, 0xaf, 0x59, 0xa5, 0xba, 0xbc, 0x24, 0x4c, 0xf2, 0xc8, - 0x38, 0xd0, 0x46, 0x86, 0x52, 0xd6, 0xd8, 0x1f, 0x72, 0x2a, 0xaa, 0x68, 0xba, 0xae, 0x32, 0xcb, - 0x5b, 0x4b, 0x4e, 0x31, 0x7f, 0x3b, 0xe0, 0x29, 0x65, 0x8d, 0xff, 0x93, 0xff, 0x2a, 0x07, 0x55, - 0x41, 0x57, 0xd0, 0x7b, 0x50, 0x31, 0x2c, 0x35, 0x76, 0x7e, 0x3b, 0xcd, 0x55, 0x2e, 0x1b, 0x16, - 0xaf, 0xf8, 0x5d, 0xa8, 0xe3, 0x13, 0x32, 0x66, 0x71, 0x95, 0x3c, 0xad, 0x72, 0x8d, 0x55, 0x88, - 0x18, 0x18, 0x13, 0x91, 0x41, 0xe1, 0x6c, 0x06, 0xac, 0x02, 0xb7, 0x9e, 0xff, 0x1b, 0xaa, 0x6c, - 0x45, 0x77, 0x8d, 0x89, 0x31, 0x33, 0x02, 0x8f, 0xae, 0x41, 0x6d, 0xa2, 0x9d, 0x44, 0xbb, 0x08, - 0x5b, 0xac, 0xd5, 0x89, 0x76, 0x12, 0x6e, 0x36, 0xef, 0xc0, 0x05, 0x8f, 0x5f, 0x17, 0xab, 0xfe, - 0x91, 0x8b, 0xbd, 0x23, 0xdb, 0xd4, 0x55, 0x67, 0xe8, 0x73, 0x43, 0xb3, 0x12, 0x60, 0x07, 0x01, - 0xb2, 0x3f, 0xf4, 0xe5, 0xdf, 0xcc, 0x43, 0x39, 0x58, 0x44, 0xe8, 0x5b, 0x50, 0xd7, 0xa6, 0xfe, - 0x91, 0xea, 0x68, 0x9e, 0xf7, 0x95, 0xed, 0xea, 0xdc, 0x96, 0xd6, 0x08, 0xb0, 0xcf, 0x61, 0xe8, - 0x2a, 0x54, 0x75, 0xec, 0x0d, 0x5d, 0xc3, 0x11, 0xee, 0x7d, 0x45, 0x10, 0xba, 0x08, 0x65, 0xb6, - 0x31, 0x6b, 0x5e, 0x10, 0xc6, 0xa5, 0xe5, 0x16, 0xdd, 0x11, 0x43, 0xb7, 0x21, 0x08, 0x33, 0x17, - 0x29, 0x87, 0x46, 0x00, 0x6f, 0xf1, 0xc8, 0xfc, 0x1a, 0x2c, 0x38, 0x18, 0xbb, 0x84, 0x09, 0x8b, - 0xd6, 0x96, 0x48, 0xb1, 0xe5, 0x11, 0x97, 0x88, 0x22, 0xc6, 0xae, 0x3d, 0x75, 0xe8, 0x52, 0xab, - 0x28, 0x15, 0x02, 0xd9, 0x25, 0x00, 0xe2, 0x12, 0x51, 0x34, 0x35, 0x7f, 0xec, 0x66, 0xaa, 0x4c, - 0x00, 0xf4, 0x12, 0x79, 0x1f, 0x96, 0x5c, 0x3c, 0xb1, 0x8f, 0xb1, 0xea, 0xb8, 0xc6, 0xb1, 0xe6, - 0x13, 0xb7, 0x8a, 0xae, 0xaa, 0xc5, 0x3b, 0x72, 0xda, 0xaa, 0xdc, 0x52, 0x28, 0x6d, 0x9f, 0x91, - 0xb6, 0x3c, 0xa5, 0xe1, 0xc6, 0x01, 0xc4, 0xa3, 0x61, 0x4b, 0x6d, 0x64, 0x6a, 0x8e, 0xaa, 0x6b, - 0x13, 0xc7, 0xb0, 0xc6, 0x74, 0xc1, 0x95, 0x15, 0x89, 0x62, 0xee, 0x9b, 0x9a, 0xb3, 0xc3, 0xe0, - 0xe8, 0x3a, 0x2c, 0x7a, 0xd8, 0xd2, 0x55, 0x7e, 0x49, 0xee, 0x3f, 0xe1, 0x0e, 0x5d, 0x9d, 0x40, - 0xb7, 0x03, 0x20, 0xe9, 0x20, 0xbf, 0x33, 0x1c, 0x6a, 0x0e, 0x5d, 0x40, 0x35, 0xa5, 0xc2, 0x20, - 0xdb, 0x1a, 0xed, 0x20, 0x1b, 0x5e, 0x82, 0xad, 0x51, 0x2c, 0x1b, 0x6f, 0x82, 0x5c, 0x84, 0xbc, - 0xa1, 0x53, 0xa7, 0xae, 0xa2, 0xe4, 0x0d, 0x1d, 0x7d, 0x00, 0x75, 0x7e, 0x53, 0x67, 0x12, 0x05, - 0xf3, 0x9a, 0x8b, 0xc9, 0xad, 0x5f, 0x50, 0x3f, 0xa5, 0xe6, 0x44, 0x05, 0x8f, 0xa8, 0x03, 0x9f, - 0x47, 0x3e, 0x53, 0xcc, 0xcb, 0xab, 0xb1, 0xc9, 0xe4, 0xd3, 0xf4, 0x06, 0xa0, 0xc8, 0x11, 0xb4, - 0x7c, 0xec, 0x8e, 0xb4, 0x21, 0xa6, 0x5e, 0x5f, 0x45, 0x59, 0x0a, 0xfd, 0xc1, 0x00, 0x41, 0xfc, - 0xf8, 0x63, 0x77, 0x44, 0x7d, 0xbe, 0x0a, 0x8d, 0x4c, 0xa3, 0xab, 0x50, 0xd3, 0x4c, 0xd3, 0xfe, - 0x4a, 0x25, 0x8a, 0xab, 0x79, 0x81, 0xa3, 0x47, 0x61, 0xbd, 0xaf, 0xac, 0x96, 0x87, 0x5e, 0x81, - 0x86, 0xcb, 0x8e, 0xb3, 0x6a, 0xa0, 0x11, 0xcb, 0x74, 0x84, 0xeb, 0x1c, 0xdc, 0xa7, 0x8a, 0x21, - 0xdf, 0x86, 0x46, 0x62, 0xc2, 0x50, 0x19, 0x8a, 0xfc, 0x5c, 0xc2, 0xaf, 0x9d, 0x73, 0xa8, 0x0a, - 0x0b, 0x4a, 0xbb, 0xdf, 0x6d, 0x6d, 0xb7, 0xa5, 0xbc, 0xfc, 0x09, 0xd4, 0xc4, 0x1d, 0x01, 0x35, - 0x61, 0x81, 0x5d, 0x2b, 0x04, 0xcf, 0xc4, 0x82, 0x22, 0x5d, 0x81, 0x9c, 0x4a, 0xf5, 0x7d, 0x33, - 0x5c, 0x81, 0x1c, 0x36, 0xf0, 0x4d, 0xf9, 0xff, 0xe6, 0x60, 0x31, 0xbe, 0x41, 0x90, 0x45, 0x99, - 0xd8, 0x53, 0xd4, 0xa1, 0x69, 0x04, 0x27, 0xfa, 0xb2, 0xb2, 0x12, 0xdf, 0x40, 0xb6, 0x29, 0x0e, - 0xdd, 0x85, 0xf5, 0x74, 0xad, 0xa9, 0x47, 0xfc, 0xc8, 0xf0, 0x09, 0xc1, 0x5a, 0xb2, 0x26, 0xc5, - 0x77, 0x74, 0xf9, 0x8f, 0x4b, 0x50, 0x09, 0xb7, 0x9b, 0x7f, 0x87, 0x25, 0x7d, 0x0b, 0xca, 0x13, - 0xec, 0x79, 0xda, 0x98, 0x3b, 0xb7, 0x31, 0xe3, 0xbd, 0xc7, 0x31, 0x4a, 0x48, 0x93, 0x69, 0x02, - 0xe6, 0xcf, 0x34, 0x01, 0xa5, 0x53, 0x4c, 0xc0, 0xc2, 0xa9, 0x26, 0xa0, 0x9c, 0x30, 0x01, 0x37, - 0xa1, 0xf4, 0xe5, 0x14, 0x4f, 0xb1, 0xc7, 0xf7, 0x45, 0x61, 0xeb, 0xfd, 0x94, 0xc2, 0x15, 0x8e, - 0x47, 0x9b, 0x59, 0xc6, 0x82, 0xad, 0xd8, 0x73, 0x1a, 0x82, 0xea, 0xb9, 0x0d, 0x41, 0x2d, 0xcb, - 0x10, 0xd0, 0x3b, 0x6e, 0xcf, 0x23, 0x47, 0x51, 0x16, 0xc4, 0xa8, 0x53, 0xaa, 0x1a, 0x07, 0xb2, - 0x19, 0x7e, 0x17, 0x2e, 0x78, 0x53, 0x87, 0x6c, 0x29, 0x58, 0x27, 0x26, 0x41, 0x3b, 0x34, 0x4c, - 0xc3, 0x27, 0xfe, 0xd7, 0x22, 0xbd, 0x5f, 0x5b, 0x0d, 0xb1, 0xdb, 0x02, 0x92, 0x8c, 0x11, 0xf1, - 0x94, 0x18, 0x5f, 0xb6, 0xb0, 0xcb, 0x87, 0x63, 0x87, 0xf1, 0xfc, 0x2e, 0x54, 0x35, 0x7d, 0x62, - 0x04, 0xcd, 0x4a, 0xc9, 0xd8, 0x49, 0xa8, 0x5f, 0xb7, 0x5a, 0x84, 0x8c, 0x79, 0x36, 0xa0, 0x85, - 0xff, 0x89, 0x1b, 0x18, 0xdc, 0xd6, 0xd3, 0xb5, 0x5e, 0x57, 0xc2, 0x32, 0xc1, 0x69, 0xc3, 0x21, - 0x76, 0x7c, 0xac, 0xf3, 0xc5, 0x1e, 0x96, 0xc9, 0x99, 0x4f, 0x8b, 0x5e, 0x6a, 0x2e, 0x73, 0x53, - 0x10, 0xbd, 0xd1, 0x5c, 0x86, 0x79, 0x7b, 0xea, 0xab, 0x5f, 0x36, 0x57, 0xd8, 0x7d, 0xad, 0x3d, - 0xf5, 0x3f, 0x25, 0x67, 0xd9, 0x91, 0x69, 0x3b, 0x5e, 0x73, 0x95, 0x02, 0x59, 0x41, 0xde, 0x04, - 0x88, 0x84, 0x43, 0x25, 0xc8, 0x3f, 0xec, 0xb3, 0xc7, 0x29, 0x3b, 0xbd, 0xcf, 0xf6, 0xa5, 0x1c, - 0x02, 0x28, 0xf5, 0xef, 0x3f, 0x56, 0xb7, 0x07, 0x52, 0x5e, 0xfe, 0x1f, 0x50, 0x0e, 0x34, 0x15, - 0xbd, 0x21, 0x88, 0xce, 0x7c, 0x89, 0xa5, 0x94, 0x3e, 0x0b, 0xbd, 0xb9, 0x0e, 0x45, 0x2f, 0x78, - 0x1d, 0x92, 0x49, 0x4a, 0xd1, 0xf2, 0x2f, 0x73, 0xb0, 0xc0, 0x21, 0x48, 0x86, 0xda, 0x7e, 0x6f, - 0xd0, 0xb9, 0xdf, 0xd9, 0x6e, 0x0d, 0x3a, 0xbd, 0x7d, 0xda, 0x4a, 0x51, 0x89, 0xc1, 0x88, 0x23, - 0xf0, 0xb0, 0xbf, 0xd3, 0x1a, 0xb4, 0x29, 0xe3, 0xa2, 0xc2, 0x4b, 0xe4, 0x48, 0xd1, 0xeb, 0xb7, - 0xf7, 0xf9, 0x2b, 0x27, 0xfa, 0x1f, 0xbd, 0x04, 0x95, 0x4f, 0xda, 0xed, 0x7e, 0xab, 0xdb, 0x79, - 0xd4, 0xa6, 0x4b, 0xb0, 0xa8, 0x44, 0x00, 0x62, 0xd2, 0x94, 0xf6, 0x7d, 0xa5, 0x7d, 0xf0, 0x80, - 0x2e, 0xb3, 0xa2, 0x12, 0x14, 0x49, 0xbd, 0x9d, 0xce, 0xc1, 0x76, 0x4b, 0xd9, 0x69, 0xef, 0xd0, - 0x05, 0x56, 0x54, 0x22, 0x00, 0x19, 0xd5, 0x41, 0x6f, 0xd0, 0xea, 0xd2, 0xe5, 0x55, 0x54, 0x58, - 0x41, 0xde, 0x82, 0x12, 0x5b, 0x25, 0x04, 0x6f, 0x58, 0xce, 0xd4, 0xe7, 0x9e, 0x0a, 0x2b, 0x10, - 0xb9, 0xed, 0xa9, 0x4f, 0xc0, 0xfc, 0x3c, 0xc1, 0x4a, 0x32, 0x86, 0x12, 0x73, 0x6c, 0xd1, 0x2d, - 0x28, 0x11, 0x5f, 0xdd, 0x18, 0xf3, 0xd1, 0xbd, 0x90, 0x74, 0x7d, 0xb7, 0x29, 0x56, 0xe1, 0x54, - 0xe8, 0xb5, 0xf8, 0x8b, 0x86, 0xd5, 0x24, 0x79, 0xec, 0x4d, 0xc3, 0x2f, 0x73, 0x50, 0x13, 0xb9, - 0x90, 0x25, 0x34, 0xb4, 0x2d, 0x0b, 0x0f, 0x7d, 0xd5, 0xc5, 0xbe, 0xfb, 0x24, 0x18, 0x6c, 0x0e, - 0x54, 0x08, 0x8c, 0xac, 0x05, 0xea, 0x2c, 0x85, 0xcf, 0x6b, 0x8a, 0x4a, 0x99, 0x00, 0x08, 0x27, - 0xb2, 0xc1, 0x7d, 0x81, 0xb1, 0xa3, 0x99, 0xc6, 0x31, 0x56, 0x13, 0xaf, 0xcc, 0x96, 0x42, 0x4c, - 0x87, 0x23, 0xd0, 0x0e, 0x5c, 0x9e, 0x18, 0x96, 0x31, 0x99, 0x4e, 0xd4, 0x50, 0x6f, 0x89, 0xdf, - 0x17, 0x55, 0x65, 0x33, 0xf4, 0x12, 0xa7, 0x6a, 0x89, 0x44, 0x01, 0x17, 0xf9, 0x17, 0x79, 0xa8, - 0x0a, 0xdd, 0xfb, 0x4f, 0xda, 0x0d, 0x1a, 0x07, 0xc3, 0x63, 0xdb, 0x37, 0x34, 0x62, 0x9c, 0x22, - 0xe1, 0x98, 0x22, 0xa2, 0x08, 0xf7, 0x20, 0x10, 0x33, 0x7a, 0x00, 0xc5, 0x14, 0x32, 0xeb, 0x01, - 0x14, 0x53, 0xc8, 0xb0, 0x2c, 0xff, 0x6b, 0x0e, 0x2a, 0xe1, 0x41, 0x28, 0xed, 0xb5, 0xe4, 0x32, - 0xbc, 0x96, 0x4b, 0x00, 0x8c, 0x48, 0x78, 0xfc, 0xc1, 0xbc, 0xaa, 0x3e, 0xe7, 0x31, 0xf1, 0xa7, - 0xaa, 0x6e, 0x78, 0x43, 0xfb, 0x18, 0xbb, 0x4f, 0x78, 0x7c, 0xa7, 0x36, 0xf1, 0xa7, 0x3b, 0x01, - 0x8c, 0x78, 0x04, 0x64, 0x57, 0x25, 0xe3, 0x39, 0xb1, 0xf5, 0xe0, 0x21, 0x42, 0x95, 0xc3, 0xf6, - 0x6c, 0x1d, 0x13, 0x3b, 0xcf, 0x3d, 0xb9, 0xf8, 0x4e, 0x57, 0x67, 0xd0, 0x56, 0xf6, 0x23, 0xb1, - 0x52, 0xf0, 0x20, 0x2b, 0x78, 0x24, 0x46, 0x36, 0x42, 0x7f, 0xe8, 0xa8, 0x13, 0xcf, 0xe3, 0x1e, - 0x6d, 0xc9, 0x1f, 0x3a, 0x7b, 0x9e, 0x27, 0x7f, 0x08, 0x55, 0xe1, 0x30, 0x87, 0x6e, 0xc1, 0xb2, - 0x78, 0xf2, 0x8b, 0xfb, 0x1a, 0x4b, 0xc2, 0x49, 0x8f, 0x39, 0x1a, 0xf2, 0xbf, 0xe4, 0xa0, 0x91, - 0x38, 0xce, 0x9d, 0xee, 0x02, 0xf1, 0x43, 0x61, 0xa4, 0x62, 0x75, 0xa5, 0xca, 0x61, 0x74, 0xfa, - 0xae, 0x40, 0xf5, 0x08, 0x9b, 0x0e, 0x76, 0x55, 0xdb, 0x32, 0x83, 0x61, 0x03, 0x06, 0xea, 0x59, - 0x26, 0xdd, 0xd2, 0x74, 0x3c, 0xc2, 0xae, 0xab, 0x99, 0x8c, 0x09, 0x7b, 0x9e, 0x56, 0x0b, 0x80, - 0x94, 0xcb, 0x6d, 0x58, 0xa1, 0x8f, 0xba, 0xf8, 0x33, 0x52, 0x35, 0x90, 0x87, 0x05, 0x9f, 0x96, - 0x45, 0x5c, 0x9b, 0xcb, 0xf6, 0x1a, 0x2c, 0x99, 0xb6, 0x35, 0x36, 0xe9, 0xa3, 0xb1, 0x80, 0xbe, - 0xc4, 0xb6, 0xdf, 0x10, 0xc1, 0x89, 0xe5, 0xb7, 0x61, 0x6d, 0xcf, 0x49, 0xf4, 0x9b, 0xdb, 0x8b, - 0x99, 0xbd, 0x97, 0xff, 0x32, 0x07, 0x17, 0x52, 0xb5, 0xd8, 0xea, 0x9c, 0x3d, 0x64, 0xe2, 0x3e, - 0xc8, 0x2e, 0x88, 0xa2, 0x9d, 0x23, 0xbe, 0xd7, 0xf1, 0xa1, 0x12, 0xf6, 0xba, 0x37, 0x60, 0x99, - 0x3f, 0x3a, 0x73, 0x8d, 0x43, 0x35, 0x64, 0x53, 0x0c, 0x3e, 0x5f, 0xd0, 0x7b, 0x23, 0x1a, 0x82, - 0x09, 0x37, 0xa2, 0x86, 0x40, 0x4e, 0xf7, 0x24, 0x36, 0x5e, 0xb5, 0x80, 0xf4, 0x80, 0x4c, 0xf9, - 0x4f, 0x73, 0xb0, 0x94, 0xea, 0x06, 0xfa, 0x76, 0xc2, 0x28, 0x5f, 0x13, 0xf6, 0xb1, 0xec, 0x91, - 0x0a, 0xed, 0xf3, 0x56, 0xdc, 0x3e, 0x5f, 0x3d, 0xa5, 0x66, 0xcc, 0x54, 0xb7, 0xa0, 0xce, 0x43, - 0x01, 0x7c, 0xe8, 0x67, 0x9d, 0x7d, 0x85, 0xd1, 0xcd, 0xc7, 0xa7, 0xe4, 0xff, 0xe7, 0xa0, 0xc6, - 0x79, 0x84, 0xcf, 0x27, 0x9f, 0x8f, 0x05, 0x51, 0x58, 0xdf, 0xf6, 0x89, 0x21, 0xe0, 0x0f, 0x71, - 0xe9, 0xd2, 0xa3, 0x20, 0x1a, 0x6b, 0x20, 0x4b, 0x98, 0x13, 0x88, 0x11, 0xdc, 0xba, 0x52, 0x67, - 0x34, 0x41, 0x14, 0xee, 0x6f, 0xf3, 0xb0, 0xc1, 0x57, 0xa2, 0xc9, 0x9e, 0x94, 0xb3, 0xf0, 0x61, - 0xb0, 0x0f, 0xbd, 0x0e, 0x48, 0x33, 0xbf, 0xd2, 0x9e, 0x78, 0xc4, 0xe7, 0x73, 0x34, 0x17, 0xab, - 0x93, 0xe8, 0x53, 0x14, 0x86, 0xd9, 0x66, 0x88, 0x3d, 0xac, 0xa3, 0xdb, 0xb0, 0x6a, 0x8c, 0x2d, - 0xdb, 0x25, 0x1e, 0x27, 0x95, 0x2c, 0xb8, 0xf0, 0xe1, 0x77, 0xe0, 0x0c, 0xd9, 0xf2, 0x88, 0x88, - 0xec, 0x92, 0x87, 0x9c, 0x19, 0x82, 0x90, 0x7d, 0xd8, 0x04, 0x5d, 0xf0, 0xf4, 0xcc, 0xc0, 0xb4, - 0x6b, 0x2d, 0xa0, 0xe0, 0x4d, 0x51, 0x81, 0xdd, 0x0e, 0x39, 0x25, 0x5e, 0x0c, 0x15, 0x4f, 0x35, - 0x2c, 0x6d, 0xe8, 0x13, 0xab, 0x46, 0xab, 0x07, 0x11, 0xeb, 0xb5, 0x90, 0xa0, 0xc3, 0xf1, 0xb4, - 0x36, 0x35, 0x5e, 0x6c, 0x30, 0x55, 0xcd, 0x18, 0x3b, 0x41, 0x80, 0x98, 0x7f, 0x5d, 0x63, 0x8c, - 0x1d, 0xf4, 0x01, 0xac, 0xf3, 0xce, 0x58, 0xf8, 0xc4, 0x57, 0x69, 0xe8, 0x7f, 0xec, 0xa8, 0x13, - 0xec, 0xbb, 0xc6, 0x90, 0xaf, 0xd1, 0x0b, 0x8c, 0x62, 0x1f, 0x9f, 0xf8, 0x0f, 0x6c, 0xa7, 0x33, - 0x76, 0xf6, 0x28, 0x56, 0xfe, 0x9b, 0x3c, 0xac, 0x67, 0x0e, 0x2b, 0x9b, 0xef, 0xff, 0x1a, 0xd5, - 0xaf, 0x35, 0xaa, 0xbf, 0x9b, 0x83, 0xd5, 0xcc, 0x51, 0x45, 0x1f, 0x26, 0xec, 0xc0, 0xf5, 0x54, - 0xd0, 0x30, 0x4b, 0xbb, 0x43, 0x5b, 0xf0, 0x41, 0xdc, 0x16, 0xbc, 0x7c, 0x46, 0xed, 0x98, 0x3d, - 0xb8, 0x03, 0x17, 0x1e, 0x7a, 0x98, 0x9e, 0xc4, 0x1d, 0x93, 0x7e, 0x57, 0xe3, 0x9d, 0x69, 0x93, - 0x6f, 0xc3, 0x6a, 0xb2, 0xce, 0x19, 0x16, 0x59, 0xfe, 0x21, 0x00, 0x39, 0xf1, 0x73, 0xd6, 0x9b, - 0xb0, 0xc4, 0x82, 0x0f, 0x13, 0xce, 0x83, 0x1c, 0xf1, 0x58, 0x8d, 0x06, 0x45, 0x04, 0xbc, 0x5b, - 0x34, 0x1c, 0x32, 0xd1, 0x4e, 0xa8, 0x4b, 0x14, 0x5c, 0x12, 0xd1, 0xad, 0x8b, 0x03, 0x59, 0x68, - 0xf2, 0x07, 0x50, 0x69, 0x87, 0xc7, 0xa8, 0x17, 0xce, 0x5d, 0x85, 0x22, 0xe1, 0x8e, 0x5e, 0x4f, - 0x4c, 0xd3, 0x4a, 0x3c, 0xc0, 0x9d, 0x98, 0x95, 0xd9, 0x6f, 0x82, 0x43, 0x51, 0x83, 0x49, 0xb8, - 0x0d, 0xd0, 0x89, 0x46, 0x27, 0x25, 0x53, 0x2e, 0x43, 0xa6, 0xb7, 0xa0, 0xd2, 0x09, 0x7b, 0x7c, - 0xae, 0x1a, 0x2a, 0x14, 0x3b, 0x67, 0xf4, 0xa2, 0xf3, 0x3c, 0xbd, 0xe8, 0x24, 0x7b, 0xf1, 0xeb, - 0x1c, 0x48, 0x49, 0xbd, 0x40, 0xef, 0x27, 0x5a, 0x13, 0x36, 0xaa, 0x6c, 0xbd, 0x0b, 0x5b, 0x7e, - 0x37, 0xde, 0xf2, 0x95, 0xd9, 0x15, 0x63, 0x8f, 0x08, 0x64, 0x28, 0xe2, 0xc3, 0xb1, 0x93, 0xfe, - 0x36, 0x8e, 0x8c, 0xba, 0x42, 0x71, 0x84, 0xc6, 0x20, 0x34, 0xa9, 0xef, 0xcf, 0x3a, 0x94, 0x86, - 0xe0, 0xe4, 0x7b, 0x7c, 0x67, 0x19, 0x68, 0xee, 0x18, 0xfb, 0x7b, 0x78, 0x72, 0x88, 0x5d, 0xef, - 0xc8, 0x10, 0x26, 0x29, 0xee, 0x51, 0xe5, 0xd2, 0x1e, 0x95, 0xdc, 0xe2, 0x66, 0x34, 0xc9, 0x23, - 0x9c, 0xb5, 0xb3, 0x59, 0x84, 0x46, 0x23, 0xc9, 0xe3, 0x4c, 0xa3, 0x91, 0x2d, 0xf8, 0x79, 0x8d, - 0x46, 0xa6, 0xc8, 0xc1, 0x4c, 0xff, 0x10, 0x2e, 0x77, 0x6d, 0x6b, 0xdc, 0x25, 0x1e, 0xd0, 0x73, - 0x3a, 0x74, 0xe7, 0x70, 0x67, 0xe5, 0xbf, 0xcb, 0xc1, 0xa5, 0x59, 0xfc, 0xbf, 0x49, 0xd7, 0x6f, - 0x13, 0x96, 0x68, 0x00, 0x2b, 0x26, 0x1f, 0xf3, 0x3b, 0x1a, 0x04, 0xa1, 0x08, 0x2e, 0xf7, 0x5d, - 0x58, 0x4f, 0xd1, 0xba, 0x2a, 0x3e, 0x71, 0x0c, 0x37, 0x74, 0x99, 0xd7, 0x12, 0x95, 0xdc, 0x36, - 0x43, 0xcb, 0xbf, 0x97, 0x83, 0xe6, 0xac, 0x0e, 0xa2, 0x8f, 0x13, 0xf3, 0x2a, 0x7c, 0x25, 0x74, - 0xfa, 0xa0, 0x87, 0x53, 0xfb, 0x61, 0x7c, 0x6a, 0x6f, 0x9c, 0xcd, 0x20, 0x36, 0xbb, 0x3f, 0x9b, - 0x87, 0x05, 0xee, 0xdf, 0xa1, 0x4f, 0x60, 0x79, 0xe2, 0xa8, 0xa9, 0xdb, 0x29, 0x26, 0xd9, 0xc6, - 0x29, 0x4e, 0xa7, 0xb2, 0x34, 0x49, 0xb9, 0xbb, 0x6f, 0x86, 0x3d, 0x63, 0x82, 0xad, 0xa5, 0xae, - 0xa7, 0x12, 0x1d, 0x49, 0x5e, 0x5d, 0x16, 0xce, 0x7d, 0x75, 0xf9, 0x19, 0xac, 0x05, 0x47, 0x32, - 0xbe, 0xf9, 0xf1, 0x9b, 0xe8, 0x20, 0x5a, 0x7a, 0xe5, 0x8c, 0x4d, 0x52, 0x59, 0x75, 0x33, 0xb7, - 0xea, 0x07, 0x80, 0xa6, 0x1e, 0x8e, 0xb6, 0x16, 0x66, 0x6f, 0xe7, 0x93, 0xf7, 0x4f, 0x49, 0x13, - 0xa5, 0x48, 0xd3, 0xa4, 0x65, 0x4c, 0xdd, 0x11, 0x94, 0x92, 0xbd, 0x9b, 0x7d, 0x47, 0x10, 0x76, - 0xcf, 0xa7, 0xcb, 0x54, 0x9d, 0x84, 0xeb, 0x94, 0xdf, 0x6c, 0x5e, 0x39, 0x63, 0x39, 0xf3, 0xee, - 0xa5, 0x8c, 0x8a, 0x06, 0x1b, 0xe4, 0xdc, 0xa6, 0xb2, 0x13, 0x5d, 0x6a, 0xde, 0xd9, 0x4d, 0xa8, - 0x7c, 0xb6, 0x42, 0x29, 0x4d, 0x73, 0x96, 0x7e, 0xc7, 0xee, 0x1d, 0x2b, 0xe7, 0xb8, 0x77, 0x6c, - 0x87, 0x9f, 0x51, 0x0b, 0xae, 0x09, 0x5f, 0xd4, 0xc1, 0xf2, 0xe7, 0x45, 0x74, 0x11, 0xca, 0x34, - 0xc4, 0x3b, 0xd1, 0x4e, 0xb8, 0x65, 0x59, 0x20, 0xe5, 0x3d, 0xed, 0x44, 0xde, 0xa1, 0x1f, 0x01, - 0xc4, 0xbd, 0x95, 0xe7, 0xe7, 0xf2, 0x05, 0x94, 0x03, 0x2e, 0xe8, 0xad, 0xc4, 0x4a, 0x6d, 0xa6, - 0xbb, 0x91, 0x50, 0xe8, 0x37, 0xe2, 0x2b, 0x73, 0x2d, 0x5d, 0x21, 0xb6, 0x12, 0xa7, 0x50, 0xe2, - 0x0f, 0x2d, 0x36, 0xa0, 0x62, 0x38, 0x6a, 0xec, 0xad, 0x45, 0xd9, 0x08, 0x5e, 0x61, 0xbc, 0x02, - 0x8d, 0x89, 0xe6, 0x7d, 0xc1, 0xfd, 0x6a, 0x75, 0x62, 0x58, 0x5c, 0xea, 0x3a, 0x01, 0x33, 0x9f, - 0x7a, 0xcf, 0xb0, 0x52, 0x74, 0xda, 0x09, 0x3f, 0x79, 0x89, 0x74, 0xda, 0x89, 0xfc, 0xb3, 0x1c, - 0x40, 0xf4, 0xe4, 0xfd, 0xb7, 0xfc, 0x2e, 0x81, 0xc0, 0x4c, 0xc3, 0xf3, 0xe9, 0xcb, 0xbc, 0x8a, - 0x42, 0xff, 0xd3, 0xa7, 0xd6, 0xf1, 0x67, 0x17, 0x52, 0x52, 0xed, 0x85, 0xb7, 0x16, 0xbb, 0x50, - 0xde, 0xd3, 0xfc, 0xe1, 0x11, 0x11, 0xe6, 0x46, 0x4c, 0x18, 0xc1, 0x1d, 0xa1, 0x14, 0x67, 0x7c, - 0x22, 0xf1, 0x08, 0x6a, 0xb1, 0x73, 0xc6, 0xad, 0x18, 0x33, 0x61, 0xf9, 0x8a, 0x54, 0x02, 0xcf, - 0x0b, 0x50, 0x12, 0xce, 0x2e, 0x75, 0x85, 0x97, 0xe4, 0x7f, 0x2c, 0x02, 0x6c, 0xdb, 0x96, 0x6e, - 0x30, 0x1b, 0x71, 0x1b, 0xf8, 0x47, 0x79, 0x6a, 0xf4, 0x9d, 0x01, 0x4a, 0x48, 0x7a, 0x80, 0x7d, - 0xa5, 0xc2, 0xa8, 0x48, 0xb7, 0xde, 0x85, 0x5a, 0x78, 0x3d, 0x43, 0x2a, 0xe5, 0x67, 0x56, 0x0a, - 0x1f, 0x80, 0x91, 0x6a, 0xdf, 0x81, 0xc5, 0xc4, 0xa1, 0xaa, 0x90, 0x8c, 0xee, 0x8a, 0x5d, 0x51, - 0x6a, 0x9a, 0xd8, 0xfd, 0x3b, 0x50, 0x0d, 0x6a, 0x93, 0x36, 0x8b, 0xb3, 0x05, 0x65, 0xd5, 0x48, - 0x8b, 0xef, 0x85, 0x5f, 0x20, 0xfb, 0x4f, 0x68, 0xad, 0xf9, 0x99, 0xb5, 0x6a, 0x21, 0x21, 0xa9, - 0xf8, 0x11, 0x2c, 0x91, 0x13, 0x53, 0xbc, 0x72, 0x69, 0x66, 0xe5, 0x06, 0x3e, 0xf1, 0xb7, 0xc5, - 0xfa, 0x57, 0xa0, 0xea, 0x3a, 0x5f, 0x18, 0xc4, 0x14, 0x4d, 0x4d, 0x9f, 0x9a, 0xb9, 0x79, 0x05, - 0x5c, 0xf6, 0x45, 0xd4, 0xd4, 0xf4, 0xd1, 0x87, 0x00, 0xd1, 0x67, 0x4e, 0xfc, 0x76, 0x59, 0xb8, - 0x3c, 0x89, 0xe6, 0x87, 0x5b, 0x44, 0x32, 0xad, 0x95, 0xf0, 0x2b, 0x28, 0x74, 0x0f, 0x96, 0x4d, - 0x62, 0x0d, 0x13, 0x12, 0x56, 0x66, 0x4a, 0xb8, 0x44, 0xc9, 0x45, 0x19, 0xe5, 0x23, 0xa8, 0x84, - 0xbc, 0xd1, 0x32, 0x34, 0x94, 0xde, 0xc3, 0x41, 0x5b, 0x1d, 0x7c, 0xde, 0x0f, 0xdf, 0x7e, 0xae, - 0xc1, 0xb2, 0x00, 0xec, 0xec, 0x0f, 0xda, 0xca, 0x7e, 0xab, 0x2b, 0xe5, 0x12, 0x88, 0xf6, 0x63, - 0x8e, 0xc8, 0xa3, 0x15, 0x90, 0x04, 0x04, 0xff, 0x9c, 0x57, 0x1e, 0x41, 0x23, 0x6c, 0xb9, 0xc5, - 0xbe, 0xa5, 0xbf, 0x1d, 0x53, 0xe6, 0x4b, 0x62, 0xcf, 0x63, 0x84, 0x82, 0x3e, 0x5f, 0x85, 0x6a, - 0xd0, 0x5b, 0x23, 0xfc, 0x32, 0x4c, 0x04, 0xc9, 0xfb, 0x50, 0xd9, 0xc3, 0x3a, 0x6f, 0xe1, 0xb5, - 0x58, 0x0b, 0x6b, 0xe2, 0xa5, 0x8b, 0x9e, 0xe2, 0xbd, 0x02, 0xf3, 0xc7, 0x9a, 0x39, 0x0d, 0x3e, - 0x9c, 0x65, 0x05, 0x59, 0x85, 0x46, 0xcb, 0xeb, 0xbb, 0xd8, 0xc1, 0x56, 0xc0, 0x55, 0x82, 0x82, - 0xe6, 0x59, 0xdc, 0xf9, 0x25, 0x7f, 0xc9, 0x32, 0x23, 0x14, 0x5a, 0x78, 0x9b, 0xc1, 0x4a, 0x48, - 0x86, 0x3a, 0xd9, 0x7b, 0x4d, 0x3c, 0xf2, 0xd5, 0x89, 0xed, 0xf9, 0xdc, 0x85, 0xab, 0x4e, 0x3d, - 0xdc, 0xc5, 0x23, 0x7f, 0xcf, 0xa6, 0xaf, 0xa9, 0xeb, 0xfc, 0x41, 0x23, 0x67, 0x7f, 0xea, 0x47, - 0x88, 0x1e, 0x36, 0x47, 0xdc, 0x4d, 0xa4, 0xff, 0xe5, 0x1b, 0xd0, 0xe8, 0xd2, 0x78, 0xb4, 0x8b, - 0x47, 0x9c, 0x41, 0xd8, 0x11, 0x7e, 0xe3, 0xc2, 0x3a, 0xf2, 0xd7, 0x05, 0x58, 0x60, 0x04, 0x5e, - 0xf4, 0xf2, 0x47, 0x63, 0x39, 0x13, 0x52, 0x86, 0x92, 0x2a, 0x05, 0xa3, 0xe6, 0x2f, 0x7f, 0x38, - 0xef, 0xf7, 0xa0, 0x12, 0x5d, 0x46, 0xe6, 0x93, 0x4f, 0x7e, 0x12, 0x13, 0xa7, 0x44, 0xb4, 0xe8, - 0x3a, 0x14, 0x26, 0xdc, 0x87, 0x8d, 0x1d, 0xca, 0xc2, 0x99, 0x50, 0x08, 0x1e, 0xbd, 0x0f, 0x40, - 0x56, 0x38, 0x1b, 0x6f, 0xbe, 0xc0, 0x2f, 0xc6, 0x6c, 0x83, 0x38, 0x15, 0x74, 0x9d, 0x33, 0x00, - 0xfa, 0x08, 0xea, 0xb1, 0xe5, 0xca, 0xd7, 0xf9, 0x29, 0xd2, 0xd5, 0xc4, 0x15, 0x8b, 0x6e, 0xc3, - 0x02, 0x7f, 0x71, 0xca, 0x17, 0xb9, 0xa0, 0x2e, 0xb1, 0x09, 0x52, 0x02, 0x3a, 0x22, 0x2c, 0xbf, - 0x1d, 0x70, 0xf1, 0x88, 0xfb, 0x31, 0x17, 0x45, 0x57, 0x23, 0x36, 0x2f, 0xc1, 0xc5, 0x81, 0x8b, - 0x47, 0xe8, 0x1e, 0x34, 0x12, 0x6b, 0x97, 0x7b, 0x2a, 0xa7, 0x88, 0xbb, 0x18, 0x5f, 0xbe, 0xf2, - 0x8f, 0x72, 0x50, 0x09, 0x3f, 0x01, 0x09, 0x77, 0x8f, 0x9c, 0xb0, 0x91, 0xbd, 0x03, 0x30, 0x0c, - 0x8d, 0x08, 0x9f, 0xad, 0x95, 0x2c, 0x03, 0xa3, 0x08, 0x74, 0xe8, 0x35, 0x58, 0x60, 0x6a, 0xe1, - 0xf1, 0xd9, 0x12, 0x1f, 0x65, 0x31, 0x84, 0x12, 0x50, 0xc8, 0x9f, 0x42, 0x89, 0x3b, 0xb0, 0x59, - 0x02, 0xc4, 0x3f, 0x22, 0xcb, 0x9f, 0xef, 0x23, 0xb2, 0xbf, 0xcf, 0x81, 0x94, 0x7c, 0x0d, 0x85, - 0x6e, 0xc6, 0x56, 0xf2, 0x4a, 0xf2, 0xdd, 0x94, 0xb0, 0x8c, 0xc5, 0x9c, 0x0b, 0xf9, 0x73, 0xe4, - 0x5c, 0xc8, 0xca, 0x90, 0x23, 0x7e, 0x58, 0x55, 0x3c, 0xeb, 0xc3, 0x2a, 0xf4, 0x26, 0x2c, 0xe8, - 0x78, 0xa4, 0x11, 0x23, 0x3f, 0x7f, 0xda, 0x42, 0x0a, 0xa8, 0xe4, 0xdf, 0xc9, 0x41, 0x41, 0xb1, - 0x35, 0xb4, 0x08, 0x79, 0x2d, 0x08, 0x7d, 0xe4, 0x35, 0x0f, 0xbd, 0x04, 0x7c, 0x83, 0x35, 0x71, - 0xe0, 0x10, 0x45, 0x00, 0x62, 0x64, 0x26, 0x1a, 0x45, 0xf1, 0x17, 0xa1, 0xac, 0x24, 0x3c, 0xc1, - 0x2c, 0xc6, 0x9e, 0xb4, 0x06, 0x8f, 0x21, 0xe7, 0x4f, 0xff, 0x14, 0x5c, 0xbe, 0xc1, 0x1e, 0xe6, - 0xda, 0xda, 0x59, 0x9f, 0x77, 0xb3, 0x2f, 0x59, 0x29, 0x61, 0xf4, 0x25, 0xab, 0x6b, 0x6b, 0x19, - 0x5f, 0xb2, 0x12, 0x22, 0x8a, 0x92, 0x3d, 0x28, 0x3c, 0x72, 0x47, 0x99, 0xda, 0xb1, 0x08, 0x79, - 0x97, 0x9d, 0x79, 0x6b, 0x4a, 0xde, 0xd5, 0xa9, 0xcb, 0xc8, 0x1e, 0xc9, 0xb9, 0xcc, 0xf9, 0xaa, - 0x29, 0x65, 0x06, 0x50, 0x68, 0xce, 0x0f, 0xfe, 0x04, 0xcf, 0xf5, 0xe9, 0x9c, 0xd4, 0x94, 0x32, - 0x03, 0x28, 0x3e, 0x7f, 0xcd, 0xc4, 0x9e, 0x7f, 0xe5, 0x0d, 0x5d, 0xfe, 0x75, 0x0e, 0x4a, 0xec, - 0xab, 0x91, 0xd4, 0x18, 0x6f, 0x40, 0x25, 0x0a, 0xcc, 0xf2, 0xfc, 0x20, 0x6e, 0x10, 0x89, 0xbd, - 0x02, 0x55, 0xe2, 0xed, 0x61, 0x8b, 0x5d, 0xb0, 0x15, 0xd8, 0x96, 0xcd, 0x40, 0xf4, 0x82, 0xed, - 0x55, 0x90, 0x38, 0x01, 0xb7, 0xc9, 0x5c, 0x41, 0x2a, 0x4a, 0x83, 0xc1, 0x5b, 0x01, 0x38, 0xf6, - 0xc2, 0x75, 0x3e, 0xf1, 0xc2, 0xf5, 0xf5, 0xcc, 0x33, 0x19, 0xbf, 0x86, 0x4a, 0x9e, 0xbb, 0xe4, - 0x5f, 0xe5, 0xa0, 0x42, 0x5f, 0xf6, 0x76, 0xac, 0x91, 0xfd, 0x8d, 0x3c, 0x2a, 0xbe, 0x01, 0x0d, - 0x6b, 0x3a, 0x51, 0x85, 0x07, 0xdd, 0xfc, 0xda, 0x76, 0xd1, 0x9a, 0x4e, 0xc4, 0x07, 0xf1, 0x17, - 0xa1, 0x6c, 0xf1, 0x98, 0x5d, 0xf0, 0x4a, 0xc0, 0x62, 0xe1, 0x3a, 0x74, 0x0d, 0x6a, 0x04, 0x15, - 0x3e, 0xd9, 0x60, 0xf7, 0xb2, 0x55, 0x6b, 0x3a, 0x69, 0x71, 0x90, 0xfc, 0x1d, 0xfa, 0xe1, 0x90, - 0x62, 0x1c, 0x92, 0x8e, 0x04, 0xda, 0x16, 0xbc, 0x85, 0x4d, 0x7d, 0x37, 0x19, 0x76, 0x99, 0xbd, - 0x85, 0x95, 0x3f, 0xa4, 0x99, 0xbb, 0xc2, 0xda, 0x5c, 0x05, 0xcf, 0x5b, 0x7d, 0xf3, 0x37, 0x79, - 0x28, 0xdd, 0x67, 0xdd, 0x9d, 0x87, 0x9c, 0x2a, 0xcd, 0x21, 0x80, 0x62, 0xa7, 0x7f, 0xfc, 0x8e, - 0xf4, 0xec, 0x69, 0x91, 0xff, 0xdf, 0x92, 0x9e, 0x3d, 0x2d, 0xa3, 0x3a, 0x2c, 0x10, 0xb8, 0xba, - 0xb7, 0x2d, 0xfd, 0xe8, 0x69, 0x91, 0x17, 0xb7, 0x58, 0xb1, 0x8c, 0x1a, 0x50, 0x61, 0xd8, 0x7e, - 0xf7, 0x40, 0xfa, 0xf1, 0xd3, 0x22, 0x07, 0x6c, 0x05, 0x80, 0x32, 0x5a, 0x84, 0x32, 0xa5, 0x78, - 0xd4, 0xdf, 0x97, 0x9e, 0x3e, 0x2b, 0xf2, 0xf2, 0x16, 0x2f, 0x97, 0xd1, 0x12, 0x54, 0x03, 0x3c, - 0x61, 0xfa, 0xec, 0x59, 0x91, 0x83, 0xb6, 0x22, 0x50, 0x99, 0x48, 0xf4, 0x88, 0x70, 0xfc, 0x8b, - 0xa7, 0x3a, 0xf9, 0xdf, 0x26, 0xb5, 0x7f, 0xf5, 0x54, 0x47, 0x15, 0x28, 0x28, 0x83, 0x6d, 0xe9, - 0xc7, 0xcf, 0x8a, 0x48, 0x02, 0xa0, 0x8c, 0xda, 0xfb, 0xdb, 0xad, 0xbe, 0xf4, 0xff, 0x9e, 0x06, - 0x90, 0xad, 0x10, 0x52, 0x46, 0x2b, 0xb0, 0x78, 0xbf, 0xdb, 0xfb, 0x4c, 0x3d, 0xe8, 0xb7, 0xb7, - 0x55, 0xda, 0xdd, 0x9f, 0x3c, 0x2b, 0xa6, 0xa0, 0x5b, 0xd2, 0x4f, 0x9e, 0x95, 0x51, 0x13, 0x50, - 0x9c, 0x96, 0x8a, 0xfc, 0xd3, 0x67, 0xc5, 0x14, 0x66, 0x8b, 0x63, 0xca, 0xe8, 0x02, 0x48, 0x11, - 0xa6, 0x7b, 0x87, 0xc3, 0x75, 0xb4, 0x08, 0xa5, 0x5e, 0xbf, 0xf5, 0xe9, 0xc3, 0xb6, 0xf4, 0xcf, - 0xcf, 0xfe, 0xe4, 0x69, 0x71, 0x73, 0x1b, 0xca, 0x81, 0x82, 0x22, 0x80, 0xd2, 0x6e, 0xb7, 0x77, - 0xaf, 0xd5, 0x95, 0xe6, 0xa2, 0x8c, 0x2f, 0xf4, 0xa5, 0x4d, 0x6b, 0xe7, 0x7b, 0x6a, 0x67, 0x5f, - 0xca, 0xa3, 0x2a, 0x2c, 0x90, 0xff, 0xbd, 0x87, 0x03, 0x96, 0x0a, 0xe6, 0x91, 0x72, 0x5f, 0x2a, - 0x6e, 0x76, 0x63, 0x4f, 0xfa, 0x59, 0x84, 0x03, 0x49, 0x50, 0xeb, 0xf6, 0x7a, 0x9f, 0x3c, 0xec, - 0xab, 0xed, 0xc7, 0xad, 0xed, 0x81, 0x34, 0x87, 0x96, 0xa0, 0xce, 0x21, 0xdd, 0xde, 0xfe, 0x6e, - 0x5b, 0x91, 0x72, 0x08, 0xc1, 0x22, 0x07, 0x1d, 0x3c, 0xe8, 0x29, 0x83, 0xb6, 0x22, 0xe5, 0x37, - 0x7d, 0xa8, 0x0a, 0x07, 0x42, 0xfa, 0xd0, 0x47, 0x69, 0xdf, 0xef, 0x3c, 0x96, 0xe6, 0x50, 0x0d, - 0xca, 0xfb, 0xed, 0xce, 0xee, 0x83, 0x7b, 0x3d, 0x52, 0x79, 0x01, 0x0a, 0x83, 0xd6, 0x2e, 0x97, - 0xea, 0x40, 0xed, 0xb7, 0x06, 0x0f, 0xa4, 0x02, 0xaa, 0x43, 0x65, 0xbb, 0xb7, 0xb7, 0xf7, 0x70, - 0xbf, 0x33, 0xf8, 0x5c, 0x22, 0x53, 0x58, 0x6f, 0x3f, 0x1e, 0xa8, 0x11, 0x68, 0x9e, 0x38, 0xd4, - 0xdd, 0x96, 0xb2, 0xdb, 0x16, 0x80, 0xa5, 0xcd, 0x57, 0xa1, 0x12, 0x9e, 0xfc, 0xe8, 0x6b, 0xc3, - 0xfd, 0xcf, 0xc5, 0x67, 0x87, 0x00, 0xa5, 0xce, 0xfe, 0xa3, 0xb6, 0x32, 0x90, 0xf2, 0x9b, 0x9b, - 0x20, 0x25, 0xcf, 0x75, 0xa8, 0x04, 0xf9, 0xf6, 0xa7, 0xd2, 0x1c, 0xf9, 0xdd, 0x6d, 0x4b, 0x39, - 0xf2, 0xdb, 0x6d, 0x4b, 0xf9, 0xcd, 0x37, 0xf9, 0x0d, 0x3f, 0xf7, 0xd3, 0xa2, 0x07, 0x8d, 0x64, - 0x54, 0xb7, 0xb7, 0xdb, 0xfd, 0x01, 0x63, 0xae, 0xb4, 0xbf, 0xd7, 0xde, 0x26, 0xcc, 0x1f, 0xc2, - 0x72, 0x86, 0x9f, 0x4d, 0xba, 0x11, 0x4a, 0xab, 0xb6, 0x76, 0x76, 0xa4, 0x39, 0xe2, 0xd0, 0x47, - 0x20, 0xa5, 0xbd, 0xd7, 0x7b, 0x44, 0x1a, 0x5e, 0x85, 0x25, 0x11, 0xca, 0x5f, 0x4a, 0x6e, 0xbe, - 0x01, 0xf5, 0x98, 0x73, 0x4d, 0xc6, 0x6c, 0xaf, 0xbd, 0xa3, 0xee, 0xf5, 0x08, 0xab, 0x06, 0x54, - 0x49, 0x21, 0x20, 0xcf, 0x6d, 0xbe, 0x0e, 0x10, 0xed, 0xe0, 0x61, 0x76, 0x2d, 0x32, 0x08, 0x7b, - 0xfd, 0x9e, 0xc2, 0x65, 0x6e, 0x3f, 0xa6, 0xff, 0xf3, 0x77, 0x7e, 0x7e, 0x15, 0xca, 0xbb, 0x64, - 0x81, 0xb7, 0x1c, 0x03, 0x75, 0xa1, 0x2a, 0x7c, 0x07, 0x88, 0x5e, 0x8a, 0xf9, 0x15, 0x89, 0xcf, - 0x0b, 0xd7, 0x2f, 0xcd, 0xc0, 0xf2, 0xef, 0x12, 0xe6, 0x50, 0x07, 0x20, 0xfa, 0x52, 0x10, 0x6d, - 0x88, 0xe4, 0x89, 0x8f, 0x0a, 0xd7, 0x5f, 0xca, 0x46, 0x86, 0xac, 0xee, 0x43, 0x25, 0xfc, 0x3e, - 0x12, 0x09, 0x67, 0xf4, 0xe4, 0x87, 0x94, 0xeb, 0x1b, 0x99, 0xb8, 0x90, 0x4f, 0x17, 0xaa, 0x42, - 0xb2, 0x37, 0xb1, 0x83, 0xe9, 0xec, 0x71, 0x62, 0x07, 0xb3, 0x32, 0xc4, 0xcd, 0xa1, 0x87, 0xb0, - 0x18, 0x4f, 0xf3, 0x86, 0xae, 0x88, 0x81, 0x91, 0x8c, 0xec, 0x71, 0xeb, 0x57, 0x67, 0x13, 0x88, - 0x42, 0x0a, 0x39, 0x0f, 0x45, 0x21, 0xd3, 0x69, 0x16, 0x45, 0x21, 0x33, 0x12, 0x25, 0xca, 0x73, - 0x48, 0x81, 0x7a, 0x2c, 0x7f, 0x1a, 0xba, 0x1c, 0xdb, 0xdf, 0xd2, 0x1c, 0xaf, 0xcc, 0xc4, 0x87, - 0x3c, 0xff, 0x3b, 0x2c, 0xa5, 0xf2, 0xb2, 0x21, 0xf9, 0xec, 0xfc, 0x70, 0xeb, 0xdf, 0x3a, 0x95, - 0x26, 0xe4, 0xff, 0xdf, 0x40, 0x4a, 0xe6, 0x5f, 0x43, 0xc2, 0xbb, 0x88, 0x19, 0x69, 0xdf, 0xd6, - 0xe5, 0xd3, 0x48, 0xc4, 0x59, 0x8b, 0x67, 0x63, 0x13, 0x67, 0x2d, 0x33, 0xb5, 0x9b, 0x38, 0x6b, - 0x33, 0x12, 0xb9, 0xcd, 0xa1, 0xc7, 0xd0, 0x48, 0x24, 0x5c, 0x43, 0xe2, 0x64, 0x67, 0x66, 0x79, - 0x5b, 0xbf, 0x76, 0x0a, 0x45, 0xc8, 0xf9, 0x43, 0x28, 0xb1, 0x5d, 0x1a, 0xad, 0xc5, 0x26, 0x3b, - 0xfa, 0xe6, 0x68, 0xbd, 0x99, 0x46, 0x84, 0xd5, 0xdf, 0x83, 0x05, 0xfe, 0x11, 0x15, 0x8a, 0x93, - 0x09, 0xdf, 0x55, 0xad, 0x27, 0xbe, 0xb7, 0x93, 0xe7, 0xde, 0xca, 0x11, 0x3d, 0x14, 0x3e, 0x38, - 0x12, 0xf5, 0x30, 0xfd, 0xd5, 0x93, 0xa8, 0x87, 0x59, 0x5f, 0x29, 0xcd, 0xa1, 0x8f, 0x61, 0x81, - 0xc7, 0x37, 0x51, 0x3a, 0x46, 0x1a, 0x70, 0xb9, 0x98, 0x81, 0x11, 0xed, 0x49, 0x94, 0xf9, 0x51, - 0xb4, 0x27, 0xa9, 0xdc, 0x95, 0xa2, 0x3d, 0xc9, 0x48, 0x16, 0x39, 0x87, 0x76, 0x00, 0xa2, 0xbc, - 0x64, 0x22, 0xab, 0x54, 0xb6, 0xb2, 0xf5, 0xec, 0x4f, 0xf5, 0xe8, 0x00, 0xdd, 0x0d, 0x73, 0xb1, - 0x45, 0xaf, 0xbe, 0x05, 0x77, 0x29, 0x4c, 0x3d, 0xba, 0x9e, 0xc8, 0x12, 0x49, 0x2b, 0xdf, 0x87, - 0x4a, 0x98, 0x1c, 0x4f, 0x34, 0x69, 0xc9, 0xd4, 0x7c, 0xa2, 0x49, 0x4b, 0x67, 0xd3, 0x63, 0xa3, - 0x12, 0xa6, 0xce, 0x8b, 0x8d, 0x4a, 0x32, 0xcb, 0x5e, 0x6c, 0x54, 0xd2, 0xd9, 0xf6, 0xe6, 0xd0, - 0x03, 0xa8, 0x84, 0xe9, 0xee, 0x44, 0x91, 0x92, 0x49, 0xf8, 0x44, 0x91, 0xd2, 0xf9, 0xf1, 0xe6, - 0x6e, 0xe6, 0x88, 0xca, 0xb2, 0x04, 0x73, 0x68, 0x6d, 0x46, 0x7e, 0xbb, 0xf5, 0x66, 0x1a, 0x21, - 0x9a, 0xfb, 0x30, 0x97, 0x9c, 0x28, 0x48, 0x32, 0x45, 0xdd, 0xfa, 0x46, 0x26, 0x4e, 0xd4, 0x39, - 0x9e, 0x3d, 0x2b, 0xa1, 0xfa, 0x42, 0xda, 0x25, 0x51, 0xe7, 0x12, 0xa9, 0xb6, 0x42, 0xad, 0x4d, - 0x72, 0x88, 0x67, 0xd5, 0x4a, 0x68, 0x6d, 0x82, 0x43, 0xa8, 0xb5, 0x94, 0x49, 0x4a, 0x60, 0x91, - 0xcf, 0x4b, 0xd9, 0x48, 0x91, 0x55, 0x94, 0xd8, 0x0a, 0xa5, 0xf4, 0x62, 0x06, 0xab, 0x8c, 0x5c, - 0x58, 0x74, 0x8f, 0x11, 0xb2, 0x5b, 0xa1, 0xb4, 0x66, 0x88, 0xcc, 0x2e, 0xcd, 0xc0, 0x8a, 0xf3, - 0x15, 0xe6, 0xa6, 0x12, 0xe7, 0x2b, 0x99, 0xe2, 0x4a, 0x9c, 0xaf, 0x74, 0x32, 0x2b, 0xba, 0x57, - 0xc5, 0xf2, 0x5c, 0x89, 0x7b, 0x55, 0x56, 0xca, 0x2c, 0x71, 0xaf, 0xca, 0x4e, 0x90, 0x15, 0x5a, - 0x4f, 0x5b, 0x4b, 0x5a, 0xcf, 0xf0, 0x74, 0x9e, 0xb4, 0x9e, 0xd1, 0x69, 0x9c, 0x0d, 0x94, 0x90, - 0x93, 0x0a, 0xa5, 0xc6, 0x55, 0xcc, 0xbb, 0x25, 0x0e, 0x54, 0x56, 0x22, 0xab, 0x39, 0xbe, 0x2e, - 0xc8, 0xe9, 0x3d, 0xbe, 0x2e, 0xa2, 0x7c, 0x52, 0x89, 0x75, 0x21, 0xe6, 0x8c, 0x12, 0xd6, 0x05, - 0xe1, 0x90, 0x5a, 0x17, 0x02, 0x93, 0x8d, 0x4c, 0x5c, 0x62, 0x4c, 0x12, 0x62, 0xc4, 0x72, 0x6c, - 0x25, 0xc6, 0x24, 0x5e, 0x5d, 0xa1, 0xe1, 0x0d, 0xe1, 0x76, 0xe8, 0x72, 0x8c, 0x38, 0x95, 0x6d, - 0x49, 0x9c, 0xa6, 0xcc, 0xf4, 0x54, 0x8c, 0x67, 0x2c, 0x6d, 0x94, 0xc8, 0x33, 0x2b, 0x1f, 0x95, - 0xc8, 0x33, 0x3b, 0xdf, 0x14, 0x75, 0x23, 0x92, 0xc9, 0xa1, 0x44, 0x37, 0x62, 0x46, 0x36, 0x2a, - 0xd1, 0x8d, 0x98, 0x99, 0x5b, 0x8a, 0xfa, 0x40, 0xa9, 0xcc, 0x50, 0xa2, 0x0f, 0x34, 0x2b, 0xf5, - 0x94, 0xe8, 0x03, 0xcd, 0x4e, 0x2d, 0x35, 0x87, 0x7a, 0x50, 0x13, 0xb3, 0x48, 0xa1, 0xb8, 0xa3, - 0x97, 0x4c, 0x98, 0xb4, 0x7e, 0x79, 0x16, 0x5a, 0x64, 0x28, 0xe6, 0x7f, 0x42, 0x71, 0xf7, 0xf6, - 0x34, 0x86, 0x99, 0x69, 0xa3, 0x98, 0xc7, 0x13, 0xcf, 0xec, 0x84, 0x52, 0xee, 0x6d, 0x8a, 0xed, - 0xb5, 0x53, 0x28, 0xc4, 0x89, 0x4b, 0xa6, 0x72, 0x12, 0x27, 0x6e, 0x46, 0xd2, 0xa8, 0x75, 0xf9, - 0x34, 0x92, 0xc4, 0x59, 0x82, 0x87, 0x58, 0xe3, 0x67, 0x89, 0x58, 0x62, 0xa2, 0xc4, 0x59, 0x22, - 0x91, 0x05, 0x88, 0xf2, 0x09, 0x13, 0xdf, 0x88, 0x7c, 0x92, 0x19, 0xa1, 0x44, 0x3e, 0xe9, 0x9c, - 0x4d, 0x74, 0x5e, 0xc4, 0x94, 0x35, 0xe2, 0xbc, 0x64, 0x24, 0x73, 0x12, 0xe7, 0x25, 0x33, 0xcf, - 0x12, 0xf7, 0xf8, 0x85, 0x1c, 0x34, 0x71, 0x8f, 0x3f, 0x9d, 0x81, 0x29, 0xee, 0xf1, 0x67, 0xa5, - 0x3c, 0x9a, 0x43, 0x3a, 0x4d, 0x75, 0x96, 0x8a, 0x21, 0xbf, 0x9c, 0x31, 0x44, 0xa9, 0x84, 0x3a, - 0xeb, 0xd7, 0xcf, 0xa0, 0x12, 0x5b, 0xc9, 0xc8, 0x25, 0x24, 0xb6, 0x32, 0x3b, 0x89, 0x91, 0xd8, - 0xca, 0x69, 0x09, 0x89, 0xe6, 0xd0, 0x24, 0x48, 0x78, 0x96, 0x6a, 0xe8, 0x46, 0xf6, 0xd8, 0xa6, - 0xdb, 0xba, 0x79, 0x36, 0x61, 0xd8, 0x9c, 0x13, 0x66, 0x39, 0x4b, 0x87, 0xe0, 0x67, 0x0c, 0x7c, - 0xba, 0xc1, 0x57, 0xcf, 0x41, 0x29, 0xfa, 0x09, 0x51, 0x58, 0x0f, 0x6d, 0x24, 0xcf, 0x06, 0x42, - 0xa8, 0x70, 0xfd, 0xa5, 0x6c, 0x64, 0xc0, 0xea, 0xb0, 0x44, 0x93, 0xfd, 0xbf, 0xfd, 0x6f, 0x01, - 0x00, 0x00, 0xff, 0xff, 0x48, 0xf3, 0x74, 0xb0, 0xfb, 0x5f, 0x00, 0x00, + // 8330 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x4d, 0x6f, 0x24, 0x47, + 0x96, 0x18, 0xeb, 0x83, 0xc5, 0xaa, 0x57, 0x55, 0xac, 0x64, 0x90, 0x6c, 0x56, 0x93, 0xea, 0xaf, + 0x1c, 0xb5, 0xba, 0xd5, 0x92, 0x28, 0x75, 0x4b, 0xa2, 0xb4, 0xd2, 0xf4, 0xec, 0x54, 0x93, 0xd5, + 0xec, 0x5a, 0x91, 0xac, 0x52, 0xb2, 0xba, 0xa7, 0x35, 0xde, 0x71, 0x3a, 0x59, 0x19, 0x55, 0x4c, + 0xab, 0x2a, 0x33, 0x27, 0x33, 0x8b, 0x22, 0x61, 0xc0, 0xee, 0x9e, 0xdd, 0x19, 0x1b, 0x30, 0xf6, + 0x62, 0x1f, 0x6d, 0xc3, 0x07, 0x5f, 0x8c, 0x85, 0x7d, 0x30, 0xb0, 0x86, 0x01, 0x5f, 0xfc, 0x01, + 0xef, 0xc2, 0xf0, 0x02, 0x3e, 0xfa, 0x68, 0xff, 0x00, 0x9f, 0x7c, 0x31, 0x0c, 0x9f, 0x8c, 0xf8, + 0xca, 0x8c, 0xfc, 0x28, 0x92, 0xdd, 0xdb, 0x5a, 0x79, 0x81, 0x39, 0xb1, 0xf2, 0xbd, 0x17, 0x2f, + 0x5e, 0x44, 0xbc, 0x88, 0xf7, 0x5e, 0x7c, 0x3c, 0x42, 0x75, 0xe4, 0x1c, 0x8d, 0xdc, 0x4d, 0xd7, + 0x73, 0x02, 0x07, 0x95, 0xe9, 0x87, 0xe1, 0x5a, 0xeb, 0x57, 0x47, 0x8e, 0x33, 0x1a, 0xe3, 0x0f, + 0x29, 0xfc, 0x68, 0x3a, 0xfc, 0xd0, 0xb0, 0xcf, 0x18, 0x91, 0xfa, 0x73, 0x40, 0xbb, 0x38, 0x38, + 0xc0, 0xd6, 0xe8, 0xf8, 0xc8, 0xf1, 0x34, 0xfc, 0xcb, 0x29, 0xf6, 0x03, 0x74, 0x0f, 0x14, 0x6c, + 0x1b, 0x47, 0x63, 0xdc, 0x32, 0x4f, 0xb0, 0x17, 0x58, 0x3e, 0x36, 0x9b, 0xb9, 0x9b, 0xb9, 0xbb, + 0x65, 0x2d, 0x05, 0x47, 0x4d, 0x58, 0x30, 0x4c, 0xd3, 0xc3, 0xbe, 0xdf, 0xcc, 0xdf, 0xcc, 0xdd, + 0xad, 0x68, 0xe2, 0x53, 0xfd, 0x12, 0x96, 0x63, 0xbc, 0x7d, 0xd7, 0xb1, 0x7d, 0x8c, 0xde, 0x86, + 0x79, 0x17, 0x63, 0xcf, 0x6f, 0xe6, 0x6e, 0x16, 0xee, 0x56, 0x1f, 0x2c, 0x6e, 0x0a, 0x39, 0x37, + 0x7b, 0x18, 0x7b, 0x1a, 0x43, 0xaa, 0x2f, 0x73, 0x50, 0x69, 0x79, 0xa3, 0xe9, 0x04, 0xdb, 0x81, + 0x8f, 0x36, 0xa1, 0xec, 0x61, 0xdf, 0x99, 0x7a, 0x03, 0x4c, 0x05, 0x59, 0x7c, 0x80, 0xa2, 0x62, + 0x1a, 0xc7, 0x68, 0x21, 0x0d, 0xba, 0x02, 0xa5, 0xa1, 0x31, 0xb1, 0xc6, 0x67, 0x54, 0xa6, 0xba, + 0xc6, 0xbf, 0x10, 0x82, 0xa2, 0x6d, 0x4c, 0x70, 0xb3, 0x40, 0x25, 0xa5, 0xbf, 0x49, 0x03, 0x06, + 0x53, 0xcf, 0xc3, 0x76, 0xd0, 0x2c, 0xd2, 0x36, 0x8a, 0x4f, 0xf5, 0x6f, 0xc1, 0x62, 0xcb, 0x34, + 0x7b, 0x46, 0x70, 0x2c, 0x3a, 0xe6, 0x55, 0xe5, 0x58, 0x85, 0xd2, 0x89, 0x37, 0xd4, 0x2d, 0x93, + 0xf7, 0xcd, 0xfc, 0x89, 0x37, 0xec, 0x98, 0x48, 0x85, 0xa2, 0x6b, 0x04, 0xc7, 0x54, 0x8c, 0x78, + 0x0f, 0x90, 0xba, 0x28, 0x4e, 0xbd, 0x0d, 0x8d, 0xb0, 0x72, 0xde, 0x73, 0x08, 0x8a, 0xd3, 0xa9, + 0xc5, 0x86, 0xa2, 0xa6, 0xd1, 0xdf, 0xea, 0x1f, 0xe7, 0x60, 0x69, 0x07, 0x8f, 0x71, 0x80, 0xbf, + 0x07, 0x39, 0xa3, 0x6e, 0x2c, 0xc4, 0xba, 0x51, 0xc8, 0x5f, 0x9c, 0x2d, 0x7f, 0x28, 0xec, 0xbc, + 0x24, 0xec, 0x0a, 0x20, 0x59, 0x56, 0xd6, 0x2c, 0xf5, 0x73, 0x40, 0x2d, 0xd3, 0x4c, 0xea, 0x20, + 0xa9, 0x03, 0x63, 0x8f, 0x8a, 0x9f, 0xd6, 0x12, 0x8a, 0x53, 0x57, 0x61, 0x39, 0x56, 0x92, 0x33, + 0xfc, 0x12, 0x56, 0x59, 0x35, 0xaf, 0xc3, 0xb3, 0x09, 0x57, 0x92, 0x85, 0x39, 0x5b, 0x13, 0x56, + 0x9f, 0xba, 0xa6, 0xf1, 0x5a, 0x6c, 0xd1, 0x1d, 0x50, 0x4c, 0x47, 0xf7, 0x9d, 0x61, 0xa0, 0x7b, + 0xd8, 0xc7, 0x81, 0x6e, 0xd9, 0xb4, 0xaf, 0xcb, 0x5a, 0xdd, 0x74, 0x0e, 0x9d, 0x61, 0xa0, 0x11, + 0x68, 0xc7, 0x56, 0x77, 0xe1, 0x4a, 0xb2, 0x16, 0x3e, 0xfc, 0x1f, 0xc0, 0xb2, 0x8d, 0xb1, 0xe9, + 0x27, 0xb8, 0xf0, 0x89, 0x49, 0x51, 0x32, 0xa3, 0x0e, 0xed, 0x1c, 0x22, 0xc2, 0xae, 0xe7, 0x4c, + 0x5d, 0x21, 0xec, 0x03, 0x00, 0x22, 0x90, 0x3e, 0x22, 0x40, 0x2e, 0xf2, 0x72, 0x5c, 0x64, 0x46, + 0x5f, 0x71, 0xc5, 0x4f, 0xf5, 0x0a, 0xac, 0xc4, 0x59, 0xf1, 0x1e, 0xd9, 0x13, 0x7d, 0xf5, 0x46, + 0x6a, 0xb9, 0x0a, 0x6b, 0x29, 0x6e, 0xbc, 0xa2, 0xa9, 0xe8, 0x94, 0x37, 0x51, 0xd1, 0xe5, 0xc7, + 0xe2, 0x09, 0xac, 0xa5, 0xaa, 0x7d, 0xbd, 0xc1, 0x30, 0xe0, 0x6a, 0xcb, 0x34, 0x77, 0xce, 0x6c, + 0x63, 0x62, 0x0d, 0x92, 0xfa, 0xb3, 0x03, 0x8a, 0xc9, 0x30, 0xba, 0xcd, 0x51, 0xbc, 0x25, 0x57, + 0xa3, 0x96, 0x24, 0xcb, 0x36, 0xcc, 0x38, 0x40, 0x7d, 0x0b, 0xd6, 0xb3, 0xaa, 0xe0, 0x3d, 0xf8, + 0x0c, 0x56, 0xa8, 0x2c, 0xc9, 0xba, 0xa5, 0xe5, 0x3b, 0x17, 0x5b, 0xbe, 0xd1, 0xdb, 0x50, 0x1f, + 0x38, 0x93, 0xc9, 0xd4, 0xb6, 0x06, 0x46, 0x60, 0x39, 0x36, 0x5f, 0x1a, 0xe2, 0x40, 0x75, 0x0d, + 0x56, 0x13, 0x7c, 0x79, 0x85, 0xff, 0x36, 0x07, 0xcd, 0xb0, 0x07, 0x2e, 0x5f, 0xeb, 0x21, 0x54, + 0x4c, 0xcb, 0xc3, 0x83, 0xb0, 0xc6, 0xc5, 0x07, 0x9f, 0x46, 0x9d, 0x30, 0x8b, 0x61, 0x84, 0xd8, + 0x11, 0x85, 0xb5, 0x88, 0x8f, 0xfa, 0x21, 0xa0, 0x34, 0x01, 0x2a, 0x41, 0xbe, 0x73, 0xa0, 0xcc, + 0xa1, 0x05, 0x28, 0x74, 0x9f, 0xf6, 0x95, 0x1c, 0x2a, 0x43, 0xf1, 0x51, 0xb7, 0xff, 0x44, 0xc9, + 0xab, 0x1b, 0x70, 0x35, 0xa3, 0x2a, 0xde, 0xb2, 0x6f, 0x60, 0xed, 0xf0, 0x78, 0x1a, 0x98, 0xce, + 0x77, 0xf6, 0x9b, 0xee, 0xcd, 0x75, 0x68, 0xa6, 0x59, 0xf3, 0x6a, 0xef, 0xc3, 0x6a, 0x9b, 0x1a, + 0xdf, 0x4b, 0x57, 0x4a, 0xd6, 0xb2, 0x64, 0x11, 0xce, 0xec, 0x39, 0x5c, 0xd9, 0xb1, 0xfc, 0x57, + 0xe2, 0x76, 0xc9, 0x26, 0x90, 0x59, 0x9c, 0xe4, 0xcc, 0x2b, 0x9d, 0xc0, 0x32, 0x9f, 0x4e, 0xce, + 0xd8, 0x1a, 0x9c, 0x89, 0x1a, 0xef, 0x42, 0xd1, 0xc7, 0x81, 0xf0, 0x07, 0x56, 0x24, 0x95, 0xc7, + 0x43, 0xcb, 0xc6, 0xe6, 0x21, 0x0e, 0x34, 0x4a, 0x81, 0xde, 0x87, 0xb2, 0x4b, 0x8a, 0x5a, 0x98, + 0x38, 0x1b, 0x84, 0x5a, 0x91, 0xa6, 0x3a, 0x63, 0x1a, 0x52, 0x90, 0x55, 0x2b, 0x5e, 0x1d, 0x17, + 0x63, 0x04, 0x0a, 0xeb, 0x95, 0x7d, 0x2f, 0x10, 0x32, 0x6c, 0x40, 0xc5, 0x9c, 0x4e, 0x5c, 0x3d, + 0x38, 0x73, 0x99, 0xc5, 0x9c, 0xd7, 0xca, 0x04, 0xd0, 0x3f, 0x73, 0x31, 0x5a, 0x87, 0xf2, 0xd0, + 0x1a, 0x63, 0xea, 0x39, 0xb0, 0x36, 0x87, 0xdf, 0x04, 0x67, 0xd9, 0x01, 0xf6, 0x4e, 0x8c, 0x31, + 0x35, 0x92, 0x45, 0x2d, 0xfc, 0x56, 0x97, 0x61, 0x49, 0xaa, 0x88, 0xd7, 0xbe, 0x0c, 0x4b, 0xbc, + 0x7f, 0xa2, 0xea, 0xa9, 0x61, 0x94, 0x80, 0x9c, 0xf4, 0xef, 0x80, 0xd2, 0xb1, 0xff, 0x26, 0x1e, + 0x04, 0x92, 0xa0, 0x6f, 0xc8, 0xb2, 0x13, 0x27, 0xcc, 0x08, 0x8e, 0xfd, 0x66, 0x21, 0xe5, 0x84, + 0x11, 0xd3, 0xcc, 0x90, 0x44, 0x56, 0x49, 0x00, 0x2e, 0xd5, 0xbf, 0xcf, 0x41, 0xbd, 0x65, 0x9a, + 0x8f, 0x26, 0xee, 0xc5, 0x2a, 0x83, 0xa0, 0xe8, 0x3a, 0x5e, 0xc0, 0xbd, 0x30, 0xfa, 0x1b, 0xfd, + 0x18, 0x8a, 0xb4, 0x97, 0x0b, 0x54, 0xfa, 0xbb, 0x51, 0xcd, 0x31, 0xa6, 0x9b, 0xfb, 0x8e, 0x6d, + 0x05, 0x8e, 0x67, 0xd9, 0x23, 0x3e, 0x7c, 0xb4, 0x94, 0xba, 0x0d, 0x4a, 0x12, 0x43, 0x26, 0x70, + 0x4f, 0x6b, 0x2b, 0x73, 0x64, 0x02, 0xf7, 0xba, 0x87, 0xb1, 0xa9, 0x8c, 0x2a, 0x30, 0xbf, 0xd7, + 0xdd, 0x6e, 0xed, 0x29, 0x05, 0x42, 0xd7, 0xda, 0xdb, 0x53, 0x8a, 0xaa, 0x42, 0x1d, 0x3b, 0x5a, + 0x19, 0x6f, 0xd4, 0x4f, 0x41, 0x61, 0xb6, 0xe7, 0x75, 0x9b, 0x45, 0xc7, 0x35, 0xe2, 0xc0, 0xd9, + 0xf6, 0x61, 0x89, 0x4b, 0xab, 0x59, 0x47, 0x82, 0xef, 0x6d, 0x98, 0x0f, 0xc8, 0x50, 0xf3, 0x35, + 0xbe, 0x11, 0xf5, 0x40, 0x9f, 0x80, 0x35, 0x86, 0x95, 0xfd, 0xd2, 0x7c, 0xdc, 0x2f, 0x6d, 0x43, + 0x59, 0xeb, 0x7d, 0xd5, 0xd9, 0x76, 0xec, 0xe1, 0x39, 0x42, 0xde, 0x80, 0xaa, 0x87, 0x27, 0x4e, + 0x80, 0xf5, 0x50, 0xd6, 0x8a, 0x06, 0x0c, 0xd4, 0x23, 0x12, 0xff, 0xe3, 0x22, 0x54, 0x08, 0x9f, + 0xc3, 0xc0, 0x08, 0xa8, 0xcb, 0x3c, 0x75, 0x03, 0x6b, 0xc2, 0xc4, 0x2a, 0x68, 0xfc, 0x8b, 0x28, + 0x38, 0x59, 0x8e, 0x28, 0x26, 0x4f, 0x31, 0xe1, 0x37, 0x5a, 0x84, 0xfc, 0xd4, 0xa5, 0x03, 0x59, + 0xd6, 0xf2, 0x53, 0x97, 0x55, 0x39, 0x70, 0x3c, 0x53, 0xb7, 0xdc, 0x93, 0x4f, 0xa8, 0x7b, 0x58, + 0x27, 0x55, 0x12, 0x50, 0xc7, 0x3d, 0xf9, 0x24, 0x4e, 0xb0, 0x45, 0x7d, 0x43, 0x99, 0x60, 0x8b, + 0x10, 0xb8, 0x1e, 0x1e, 0x5a, 0xa7, 0x8c, 0x43, 0x89, 0x11, 0x30, 0x90, 0xe0, 0x10, 0x11, 0x6c, + 0x35, 0x17, 0x12, 0x04, 0x5b, 0xa4, 0x1d, 0x3e, 0xf6, 0x2c, 0x63, 0xdc, 0x2c, 0x33, 0x9f, 0x95, + 0x7d, 0xa1, 0x1f, 0x41, 0xdd, 0xc3, 0x03, 0x6c, 0x9d, 0x60, 0x2e, 0x5d, 0x85, 0x36, 0xa6, 0x26, + 0x80, 0x94, 0x7b, 0x82, 0x68, 0xab, 0x09, 0x29, 0xa2, 0x2d, 0x42, 0xc4, 0x78, 0xea, 0xb6, 0x13, + 0x58, 0xc3, 0xb3, 0x66, 0x95, 0x11, 0x31, 0xe0, 0x01, 0x85, 0x11, 0x39, 0x07, 0xc6, 0xe0, 0x18, + 0x33, 0xd7, 0xa0, 0x59, 0xa3, 0x24, 0x40, 0x41, 0xd4, 0xaa, 0xa0, 0xdb, 0xb0, 0x18, 0x12, 0x50, + 0x65, 0x69, 0xd6, 0x29, 0x4d, 0x5d, 0xd0, 0x30, 0x3f, 0xe3, 0x3a, 0x54, 0xb1, 0x6d, 0xea, 0xce, + 0x50, 0x37, 0x8d, 0xc0, 0x68, 0x2e, 0x52, 0x9a, 0x0a, 0xb6, 0xcd, 0xee, 0x70, 0xc7, 0x08, 0x0c, + 0xb4, 0x02, 0xf3, 0xd8, 0xf3, 0x1c, 0xaf, 0xd9, 0xa0, 0x18, 0xf6, 0x81, 0x6e, 0x01, 0x97, 0x46, + 0xff, 0xe5, 0x14, 0x7b, 0x67, 0x4d, 0x85, 0x22, 0xab, 0x0c, 0xf6, 0x35, 0x01, 0xb1, 0xa1, 0x20, + 0x5e, 0x0b, 0xa3, 0x58, 0x62, 0x02, 0x52, 0x10, 0x25, 0x50, 0xbf, 0x81, 0xa2, 0xe6, 0x7e, 0x6b, + 0xa1, 0x77, 0xa0, 0x38, 0x70, 0xec, 0x21, 0xd7, 0x56, 0x79, 0xb5, 0xe1, 0x3a, 0xa8, 0x51, 0x3c, + 0x7a, 0x17, 0xe6, 0x7d, 0xa2, 0x49, 0x54, 0x4b, 0x62, 0x4e, 0x58, 0xa8, 0x64, 0x1a, 0xa3, 0x50, + 0xef, 0xc2, 0xe2, 0x2e, 0x0e, 0x08, 0x77, 0x31, 0x27, 0xa2, 0x48, 0x23, 0x27, 0x47, 0x1a, 0xea, + 0x97, 0xd0, 0x08, 0x29, 0x79, 0x8f, 0xdc, 0x85, 0x05, 0x1f, 0x7b, 0x27, 0x99, 0x11, 0x24, 0x25, + 0x14, 0x68, 0xf5, 0xe7, 0x74, 0x9a, 0xcb, 0xd5, 0xbc, 0xda, 0x4a, 0xb5, 0x0e, 0xe5, 0xb1, 0x35, + 0xc4, 0x54, 0xf5, 0x0b, 0x4c, 0xf5, 0xc5, 0xb7, 0xba, 0x44, 0xc3, 0x33, 0x59, 0x30, 0xb5, 0x25, + 0x56, 0x80, 0xd7, 0xae, 0x31, 0x0a, 0x90, 0x62, 0x8c, 0x3f, 0x10, 0x76, 0xe4, 0x52, 0x8c, 0x09, + 0x13, 0x99, 0x9c, 0x33, 0xd9, 0x0c, 0x4d, 0xcc, 0xe5, 0xb8, 0xac, 0xc2, 0x72, 0x8c, 0x9e, 0xb3, + 0x79, 0x1f, 0x14, 0xaa, 0xbf, 0x97, 0x63, 0xb2, 0x0c, 0x4b, 0x12, 0x35, 0x67, 0xf1, 0x11, 0xac, + 0x84, 0xce, 0xd5, 0xe5, 0xd8, 0xac, 0xc1, 0x6a, 0xa2, 0x04, 0x67, 0xf5, 0xe7, 0x39, 0xd1, 0xd6, + 0x9f, 0xe3, 0x23, 0xcf, 0x10, 0x9c, 0x14, 0x28, 0x4c, 0xbd, 0x31, 0xe7, 0x42, 0x7e, 0x52, 0x6d, + 0x77, 0xa6, 0x01, 0xa6, 0x06, 0x9e, 0x39, 0x0f, 0x64, 0x31, 0x24, 0x20, 0x62, 0xe2, 0x7d, 0x52, + 0x39, 0xd1, 0x19, 0xe2, 0xd6, 0xb0, 0x58, 0x57, 0x7c, 0xa2, 0x4f, 0xe0, 0x8a, 0x8d, 0x4f, 0x83, + 0x63, 0xc7, 0xd5, 0x03, 0xcf, 0x1a, 0x8d, 0xb0, 0xa7, 0xb3, 0x4d, 0x10, 0xbe, 0x5d, 0xb0, 0xc2, + 0xb1, 0x7d, 0x86, 0x64, 0xe2, 0xa0, 0x07, 0xb0, 0x9a, 0x2c, 0x65, 0xe2, 0xb1, 0x71, 0xc6, 0xd7, + 0xbc, 0xe5, 0x78, 0xa1, 0x1d, 0x82, 0x22, 0x5d, 0x1e, 0x6b, 0x0c, 0x6f, 0x64, 0x03, 0xea, 0xbb, + 0x38, 0x78, 0xe6, 0x0d, 0x85, 0xb7, 0xf0, 0x31, 0x9d, 0x3e, 0x14, 0xc0, 0xe7, 0xc4, 0x2d, 0x28, + 0x9e, 0x78, 0x43, 0x31, 0x21, 0xea, 0xd1, 0x84, 0x20, 0x44, 0x14, 0xa5, 0x7e, 0x44, 0xad, 0x76, + 0xc4, 0x05, 0xdd, 0x80, 0xc2, 0x89, 0x27, 0xa6, 0x75, 0xa2, 0x08, 0xc1, 0x70, 0x2b, 0x29, 0x55, + 0xa3, 0x7e, 0x2c, 0xac, 0xe4, 0xab, 0xb0, 0x09, 0x0d, 0xa3, 0xcc, 0xe9, 0x29, 0xac, 0xec, 0xe2, + 0x40, 0x72, 0xf0, 0x38, 0xb7, 0x77, 0xb9, 0x73, 0xc0, 0x5c, 0x9b, 0xd5, 0x94, 0x2f, 0x48, 0x06, + 0x8b, 0x79, 0x02, 0xe1, 0x5e, 0x4e, 0x3e, 0xda, 0xcb, 0x51, 0x5b, 0xb0, 0x9a, 0x60, 0x1b, 0x2e, + 0x1a, 0x97, 0xf4, 0x31, 0xd5, 0x9f, 0xd0, 0x58, 0x37, 0x2d, 0xd9, 0x3b, 0x50, 0x20, 0x0b, 0x39, + 0x6b, 0x67, 0x36, 0x03, 0x42, 0x40, 0x74, 0x35, 0x51, 0x9e, 0x37, 0xf9, 0x50, 0x84, 0xb7, 0xaf, + 0xcd, 0x9b, 0xe8, 0xb5, 0x31, 0x1e, 0x73, 0x77, 0x80, 0xfc, 0x24, 0x01, 0x43, 0x9a, 0x29, 0xaf, + 0xf0, 0x11, 0x34, 0x35, 0xec, 0x8e, 0x8d, 0xc1, 0xeb, 0xd7, 0x48, 0x02, 0xa1, 0x0c, 0x1e, 0xbc, + 0x82, 0x55, 0xba, 0xc1, 0x47, 0x57, 0xf6, 0x09, 0xb6, 0x43, 0x67, 0xf6, 0x2b, 0x3a, 0xb6, 0x12, + 0x98, 0x8f, 0xc1, 0xc7, 0x00, 0xbe, 0x00, 0x8a, 0x91, 0x90, 0xac, 0x44, 0x54, 0x40, 0x22, 0x53, + 0x9f, 0xd0, 0x5d, 0x8c, 0x64, 0x1d, 0xe8, 0x3e, 0x54, 0x42, 0xa2, 0x74, 0xd4, 0x1f, 0x91, 0x47, + 0x54, 0x7c, 0x13, 0x23, 0x25, 0x96, 0xfa, 0x0b, 0xb1, 0x89, 0xf1, 0x06, 0x2a, 0xc9, 0x18, 0xa1, + 0x70, 0x57, 0x23, 0x5d, 0xf3, 0x1e, 0xac, 0xf1, 0xce, 0x7d, 0x13, 0xed, 0x5b, 0x0f, 0x87, 0x3b, + 0x5d, 0x13, 0x02, 0x65, 0x17, 0x07, 0xb1, 0xb0, 0x8b, 0x98, 0x2b, 0x09, 0xc6, 0xc7, 0x48, 0x8e, + 0xb0, 0x72, 0x17, 0x46, 0x58, 0xa7, 0xa0, 0xb4, 0x4c, 0x33, 0x19, 0xcd, 0x95, 0x28, 0xfe, 0x8c, + 0x8b, 0x9d, 0x2e, 0xcf, 0xf1, 0xe8, 0x0b, 0xb8, 0xea, 0xe1, 0x21, 0x59, 0x4e, 0x4f, 0x2d, 0x3f, + 0xb0, 0xec, 0x91, 0x2e, 0xa9, 0x07, 0xeb, 0xc1, 0x35, 0x4a, 0xd0, 0xe6, 0xf8, 0xc3, 0x48, 0x2d, + 0x96, 0x61, 0x49, 0xaa, 0x99, 0xb7, 0xf2, 0x57, 0x39, 0x58, 0xe6, 0x3b, 0x48, 0xaf, 0x29, 0xd2, + 0x87, 0xb0, 0xec, 0x12, 0x17, 0xc8, 0x3b, 0xc1, 0x69, 0x61, 0x90, 0x40, 0x45, 0x72, 0x88, 0xf1, + 0x2e, 0x44, 0xe3, 0x7d, 0x05, 0x56, 0xe2, 0x32, 0x70, 0xe1, 0xfe, 0x65, 0x0e, 0x56, 0xf8, 0xf8, + 0xfc, 0x00, 0x1d, 0x36, 0xab, 0x65, 0x85, 0x59, 0x2d, 0x63, 0x1b, 0x3b, 0x31, 0x71, 0xc3, 0xad, + 0x83, 0xf5, 0x50, 0x6f, 0x5a, 0xbe, 0x6f, 0x8d, 0x6c, 0x59, 0x71, 0xbf, 0x00, 0x30, 0x42, 0x20, + 0x6f, 0xd1, 0x7a, 0xb2, 0x45, 0x52, 0x31, 0x89, 0x5a, 0xfd, 0x06, 0x36, 0x32, 0x39, 0x73, 0xdd, + 0xfc, 0x8b, 0xb0, 0x7e, 0x4e, 0x37, 0xc7, 0xbe, 0x0f, 0xa1, 0xaf, 0xc1, 0x46, 0x26, 0xe7, 0x70, + 0xcf, 0xe3, 0x9a, 0xac, 0x0e, 0x6f, 0xb4, 0xee, 0x8c, 0xd5, 0xe6, 0x26, 0x5c, 0x9f, 0x55, 0x1d, + 0x17, 0xe8, 0xf7, 0xe1, 0x7a, 0x6c, 0x5c, 0xdf, 0x6c, 0x6f, 0xdc, 0x82, 0x1b, 0x33, 0xb9, 0xc7, + 0xd6, 0xa2, 0x43, 0xea, 0xa3, 0x8b, 0xb5, 0xe8, 0x21, 0x5d, 0x8b, 0x04, 0x2c, 0xb4, 0xd9, 0xa5, + 0xd1, 0xd8, 0x39, 0x32, 0xc6, 0xe9, 0x89, 0xb1, 0x4b, 0xe1, 0x1a, 0xc7, 0xab, 0x3f, 0x01, 0x74, + 0x18, 0x18, 0x5e, 0x9c, 0xe9, 0x2b, 0x94, 0x5f, 0x85, 0xe5, 0x58, 0xf9, 0x68, 0xab, 0xe6, 0x30, + 0x70, 0xdc, 0xb8, 0xa8, 0x2b, 0xa4, 0xae, 0x08, 0xc8, 0x49, 0xff, 0x59, 0x01, 0x16, 0x49, 0x98, + 0xf3, 0xcc, 0x18, 0x5b, 0x26, 0xdd, 0x08, 0x43, 0x9f, 0x88, 0x78, 0x88, 0xf9, 0x32, 0xd7, 0xe3, + 0xf1, 0x50, 0x44, 0xb8, 0x29, 0x87, 0x46, 0xe8, 0x33, 0x28, 0x79, 0xd8, 0xf0, 0xc3, 0xcd, 0xcf, + 0x1b, 0x33, 0x8b, 0x69, 0x94, 0x4c, 0xe3, 0xe4, 0xe8, 0x0e, 0x2c, 0x4c, 0x8c, 0x60, 0x70, 0x8c, + 0x4d, 0xbe, 0xa7, 0x23, 0xf9, 0x62, 0x9a, 0x63, 0x68, 0x02, 0x8b, 0x3e, 0x82, 0xda, 0xd4, 0xe6, + 0x1f, 0xba, 0xe1, 0x37, 0x8b, 0x59, 0xd4, 0xd5, 0x90, 0xa4, 0xe5, 0xa3, 0xcf, 0x41, 0x89, 0x4a, + 0x8c, 0xb1, 0x3d, 0x0a, 0x8e, 0x9b, 0xf3, 0x59, 0xa5, 0x1a, 0x21, 0xd9, 0x1e, 0xa5, 0x52, 0x7b, + 0x30, 0xcf, 0x76, 0x17, 0x16, 0x01, 0x0e, 0xfb, 0xad, 0x7e, 0x5b, 0x3f, 0xe8, 0x1e, 0xb4, 0x95, + 0x39, 0xb4, 0x0c, 0x0d, 0xf1, 0xdd, 0xd7, 0x1f, 0x77, 0x9f, 0x1e, 0xec, 0x28, 0x39, 0xd4, 0x80, + 0x2a, 0x03, 0x3e, 0x6b, 0xed, 0x75, 0x76, 0x94, 0x3c, 0x5a, 0x82, 0x3a, 0x03, 0x74, 0x0e, 0x18, + 0xa8, 0xa0, 0x7e, 0x09, 0x25, 0xd6, 0x70, 0x42, 0xad, 0xb5, 0x5b, 0x87, 0xdd, 0xbe, 0xe0, 0x59, + 0x87, 0x0a, 0x05, 0x1c, 0xe8, 0xad, 0x43, 0x25, 0x47, 0x0a, 0xf3, 0xcf, 0xbd, 0xf6, 0xc1, 0x2e, + 0xdd, 0xd6, 0xfd, 0x6f, 0xf3, 0x50, 0xec, 0xf1, 0xc3, 0x29, 0x7b, 0xec, 0x59, 0xe2, 0x24, 0x8d, + 0xfc, 0x26, 0x21, 0xa8, 0x6b, 0x04, 0x81, 0xc7, 0xa2, 0x83, 0x9a, 0xc6, 0xbf, 0xe8, 0x24, 0x1b, + 0x89, 0x00, 0x90, 0xfc, 0x24, 0xa5, 0x8f, 0xb0, 0x2f, 0x8e, 0x0b, 0xe9, 0x6f, 0x12, 0x60, 0x58, + 0xbe, 0xfe, 0x9d, 0x15, 0x1c, 0x9b, 0x9e, 0xf1, 0x1d, 0xf5, 0xf2, 0xcb, 0x1a, 0x58, 0xfe, 0xcf, + 0x38, 0x04, 0x5d, 0x07, 0x38, 0x09, 0x07, 0x8f, 0x6e, 0x6c, 0xcc, 0x6b, 0x12, 0x04, 0xb5, 0x61, + 0x29, 0xfa, 0xd2, 0x4d, 0x1c, 0x18, 0xd6, 0x98, 0x6e, 0x6f, 0x54, 0x1f, 0x34, 0x67, 0xe9, 0x80, + 0xa6, 0x44, 0x45, 0x76, 0x68, 0x09, 0xf4, 0x11, 0xac, 0xd8, 0x8e, 0x6e, 0x4d, 0x5c, 0x62, 0xa2, + 0x83, 0x48, 0xa0, 0x32, 0x5b, 0xe8, 0x6d, 0xa7, 0xc3, 0x51, 0xa1, 0x60, 0x51, 0xe8, 0x5d, 0x89, + 0x1d, 0xf2, 0x5d, 0x03, 0x60, 0x7b, 0x88, 0xba, 0xe1, 0xdb, 0x74, 0x23, 0xa4, 0xae, 0x55, 0x18, + 0xa4, 0xe5, 0xdb, 0x68, 0x03, 0xf8, 0x87, 0x6e, 0x99, 0x74, 0x07, 0xa4, 0xa2, 0x95, 0x19, 0xa0, + 0x63, 0xf2, 0x1d, 0xd3, 0x00, 0x7b, 0xd8, 0xa4, 0x5b, 0x1f, 0x65, 0x2d, 0xfc, 0x46, 0x2b, 0x74, + 0x5e, 0x8c, 0xd9, 0x7e, 0x47, 0x59, 0x63, 0x1f, 0xe8, 0x2e, 0x28, 0x96, 0xaf, 0x0f, 0x3d, 0x67, + 0xa2, 0xe3, 0xd3, 0x00, 0x7b, 0xb6, 0x31, 0xa6, 0x9b, 0x1d, 0x65, 0x6d, 0xd1, 0xf2, 0x1f, 0x7b, + 0xce, 0xa4, 0xcd, 0xa1, 0xa4, 0xa7, 0xc5, 0x29, 0x89, 0x6e, 0xb9, 0x74, 0xdf, 0xa3, 0xa2, 0x81, + 0x00, 0x75, 0xdc, 0xf0, 0xe4, 0x51, 0x89, 0x4e, 0x1e, 0xd1, 0xfb, 0x80, 0x2c, 0x5f, 0x17, 0x11, + 0x99, 0x65, 0xd3, 0x7e, 0xa3, 0x9b, 0x1e, 0x65, 0x4d, 0xb1, 0xfc, 0x03, 0x86, 0xe8, 0x30, 0x38, + 0x19, 0x2b, 0xcb, 0xc4, 0x76, 0x60, 0x0d, 0x2d, 0xec, 0x35, 0x11, 0xdb, 0x63, 0x8a, 0x20, 0xe8, + 0x5d, 0x50, 0xc6, 0xce, 0xc0, 0x18, 0xeb, 0x12, 0xd5, 0x32, 0xa5, 0x6a, 0x50, 0x78, 0x27, 0x22, + 0xfd, 0x10, 0xca, 0x86, 0x7d, 0xa6, 0x53, 0x6d, 0x5b, 0x09, 0xbd, 0x6d, 0x67, 0x34, 0xc6, 0x9b, + 0xe2, 0x38, 0x7e, 0xb3, 0x65, 0x9f, 0x69, 0x0b, 0x86, 0x7d, 0x76, 0x40, 0xd4, 0xf0, 0x63, 0x00, + 0x52, 0x80, 0xab, 0xe2, 0x6a, 0x18, 0xaf, 0xa4, 0x8b, 0x54, 0x0c, 0xfb, 0xac, 0x47, 0xc9, 0xd4, + 0x7f, 0x9a, 0x83, 0xea, 0x0e, 0x26, 0x36, 0x9f, 0x29, 0x13, 0xd1, 0x65, 0xba, 0x25, 0xc6, 0x63, + 0x60, 0xfe, 0x15, 0x6d, 0xfb, 0xe6, 0xcf, 0xd9, 0xf6, 0x45, 0x77, 0xa0, 0x31, 0x76, 0x6c, 0x12, + 0xb2, 0xb2, 0x62, 0x58, 0xf8, 0x09, 0x8b, 0x0c, 0xdc, 0xe3, 0x50, 0xd2, 0x0f, 0xfe, 0xb1, 0xe3, + 0x05, 0x32, 0x25, 0x9b, 0x14, 0x0d, 0x0e, 0x17, 0xa4, 0xea, 0xbf, 0xc9, 0xc1, 0x3c, 0xdd, 0xde, + 0x44, 0xef, 0xc4, 0x42, 0xbc, 0xac, 0xdd, 0xeb, 0x99, 0xf1, 0xdd, 0xcc, 0x03, 0xe9, 0xdf, 0x81, + 0x9a, 0x19, 0x35, 0x5f, 0xac, 0x69, 0xb1, 0xf0, 0x31, 0xc4, 0x6a, 0x31, 0x52, 0xba, 0xa1, 0xe8, + 0xf8, 0x81, 0xce, 0x7d, 0x30, 0x3e, 0x71, 0x09, 0x88, 0x59, 0x30, 0x75, 0x8b, 0x86, 0xdf, 0xaf, + 0xbc, 0x7f, 0xab, 0x7e, 0xc6, 0x36, 0xb9, 0x48, 0x39, 0x6e, 0xd0, 0x2e, 0x59, 0x70, 0x02, 0x4b, + 0xf4, 0x7b, 0xcf, 0x71, 0xbe, 0x9d, 0xba, 0xac, 0x07, 0x67, 0x8e, 0xe8, 0x4f, 0xa1, 0x3e, 0xa6, + 0x74, 0xba, 0xe3, 0x4a, 0x67, 0x66, 0x1b, 0x09, 0xde, 0x8c, 0x57, 0xd7, 0x65, 0x1d, 0x30, 0x96, + 0xbe, 0xd4, 0x7f, 0x92, 0xa3, 0x82, 0xca, 0xd7, 0x07, 0xbe, 0x8f, 0x21, 0xfa, 0x0c, 0xca, 0x92, + 0x8e, 0x90, 0xe1, 0xc9, 0x96, 0x91, 0xb5, 0x57, 0x0b, 0x89, 0xd5, 0x31, 0x20, 0xbe, 0xe2, 0x61, + 0x69, 0x10, 0x2e, 0x2b, 0xe2, 0xac, 0x9b, 0x20, 0x51, 0x7f, 0x16, 0xe4, 0xfe, 0x24, 0xae, 0x40, + 0xac, 0x36, 0x6e, 0xdf, 0xff, 0x67, 0x11, 0x8a, 0x3d, 0x8c, 0x3d, 0xba, 0xb2, 0x11, 0x0e, 0x22, + 0x40, 0xaa, 0x6b, 0xe1, 0x37, 0xfa, 0x1c, 0x6a, 0x86, 0xeb, 0x8e, 0xcf, 0x84, 0x2e, 0xb1, 0x8d, + 0x50, 0x49, 0x0b, 0x5b, 0x04, 0xcb, 0xdd, 0xe9, 0xaa, 0x11, 0x7d, 0x84, 0x7b, 0xac, 0x85, 0xe4, + 0x1e, 0x2b, 0xa9, 0x53, 0xda, 0x63, 0xfd, 0x12, 0xea, 0xf8, 0x68, 0xe4, 0xea, 0x93, 0xe9, 0x38, + 0xb0, 0x8e, 0x1d, 0x97, 0xdf, 0xc0, 0xb8, 0x12, 0x15, 0x68, 0x1f, 0x8d, 0xdc, 0x7d, 0x8e, 0xd5, + 0x6a, 0x58, 0xfa, 0x42, 0x2d, 0x68, 0xb0, 0x3d, 0x30, 0x0f, 0x0f, 0xc7, 0x78, 0x10, 0x38, 0x1e, + 0xd5, 0xf6, 0xb8, 0x7d, 0x21, 0x04, 0x9a, 0xc0, 0x6b, 0x8b, 0x5e, 0xec, 0x1b, 0xdd, 0x81, 0xa2, + 0x65, 0x0f, 0x1d, 0x6a, 0xbe, 0x52, 0xe7, 0xec, 0xcc, 0x8f, 0xa1, 0x04, 0xc4, 0xf7, 0x0a, 0xac, + 0x09, 0xf6, 0x7c, 0x6e, 0xc2, 0x24, 0xdf, 0xab, 0x4f, 0xe1, 0x1a, 0xc7, 0x93, 0x48, 0x37, 0xf0, + 0x0c, 0xdb, 0xa7, 0x7b, 0xa1, 0xe5, 0x24, 0xdf, 0xbe, 0x40, 0x69, 0x11, 0x15, 0xe9, 0x67, 0xd6, + 0x10, 0xb6, 0xd1, 0x4b, 0xed, 0x56, 0xac, 0x9f, 0x69, 0x2b, 0xb8, 0x87, 0xc6, 0xf6, 0xfd, 0xd8, + 0x07, 0xda, 0x01, 0x65, 0xe4, 0x19, 0x03, 0x3c, 0x9c, 0x8e, 0x75, 0x0f, 0xfb, 0xc4, 0xe7, 0xa3, + 0x96, 0x2d, 0x76, 0xd2, 0xbe, 0xcb, 0x29, 0x34, 0x46, 0xa0, 0x35, 0x46, 0x71, 0x00, 0xda, 0x84, + 0x8a, 0x31, 0xb4, 0x74, 0xdf, 0x18, 0x5a, 0x7e, 0xb3, 0x4a, 0x75, 0x79, 0x49, 0x1a, 0xe4, 0xa1, + 0x75, 0x68, 0x0c, 0x2d, 0xad, 0x6c, 0xb0, 0x1f, 0x24, 0xf6, 0xaa, 0x18, 0xa6, 0xa9, 0xb3, 0x95, + 0xb7, 0x96, 0x1c, 0x62, 0x7e, 0xcb, 0xc7, 0xd7, 0xca, 0x06, 0xff, 0xa5, 0xfe, 0xdf, 0x22, 0x54, + 0xc2, 0x2b, 0x07, 0xdf, 0x93, 0xca, 0xbd, 0x17, 0x53, 0xb9, 0xb5, 0x8c, 0x2b, 0x13, 0xff, 0x1f, + 0xe9, 0xdd, 0xfb, 0x31, 0xbd, 0x6b, 0x66, 0x08, 0xfb, 0x5b, 0xe5, 0x7b, 0x53, 0xca, 0xf7, 0x04, + 0x1a, 0x89, 0x4b, 0x24, 0x33, 0x8d, 0xcf, 0xb5, 0xd8, 0xe5, 0x1b, 0x66, 0x05, 0xa4, 0x0b, 0x3d, + 0xff, 0x39, 0x07, 0x55, 0x49, 0xff, 0xd0, 0x67, 0x50, 0xb1, 0x6c, 0x3d, 0xb6, 0xd9, 0x71, 0x5e, + 0x5c, 0x59, 0xb6, 0x6c, 0x5e, 0xf0, 0x77, 0xa1, 0x8e, 0x4f, 0x49, 0xef, 0xc7, 0xd5, 0xfc, 0xbc, + 0xc2, 0x35, 0x56, 0x20, 0x62, 0x60, 0x4d, 0x64, 0x06, 0x85, 0x8b, 0x19, 0xb0, 0x02, 0xdc, 0x09, + 0xf8, 0xdb, 0x50, 0x65, 0x86, 0x69, 0xcf, 0x9a, 0x58, 0x33, 0x8f, 0xab, 0xd0, 0x2d, 0xa8, 0x4d, + 0x8c, 0xd3, 0xc8, 0x19, 0x62, 0x36, 0xa7, 0x3a, 0x31, 0x4e, 0x43, 0x9f, 0xe9, 0x13, 0xb8, 0xe2, + 0xf3, 0x2b, 0x1e, 0x7a, 0x70, 0xec, 0x61, 0xff, 0xd8, 0x19, 0x9b, 0xba, 0x3b, 0x08, 0xb8, 0xbd, + 0x5c, 0x11, 0xd8, 0xbe, 0x40, 0xf6, 0x06, 0x81, 0xfa, 0xcf, 0x4b, 0x50, 0x16, 0xb6, 0x00, 0xfd, + 0x08, 0xea, 0xc6, 0x34, 0x38, 0xd6, 0x5d, 0xc3, 0xf7, 0xbf, 0x73, 0x3c, 0x93, 0x8f, 0x4a, 0x8d, + 0x00, 0x7b, 0x1c, 0x86, 0x6e, 0x42, 0xd5, 0xc4, 0xfe, 0xc0, 0xb3, 0x5c, 0xe9, 0xae, 0x86, 0x0c, + 0x42, 0x57, 0xa1, 0xcc, 0xbc, 0x58, 0xc3, 0x17, 0x67, 0x1e, 0xf4, 0xbb, 0x45, 0x1d, 0xbb, 0xd0, + 0xc7, 0x16, 0x67, 0x32, 0x45, 0xca, 0xa1, 0x21, 0xe0, 0x2d, 0x7e, 0x8c, 0xb5, 0x06, 0x0b, 0x54, + 0x07, 0x0c, 0x9f, 0x1f, 0x6d, 0x94, 0xc8, 0x67, 0xcb, 0x4f, 0x28, 0x47, 0x29, 0xa1, 0x1c, 0x24, + 0x7e, 0xa0, 0x68, 0x6a, 0xc5, 0xd9, 0x31, 0x6e, 0x99, 0x00, 0xe8, 0x8d, 0x8b, 0x03, 0x58, 0xf2, + 0xf0, 0xc4, 0x39, 0xc1, 0xba, 0xeb, 0x59, 0x27, 0x46, 0x40, 0x62, 0x10, 0x3a, 0x3f, 0x17, 0x1f, + 0xa8, 0x69, 0xe3, 0xb8, 0xa9, 0x51, 0xda, 0x1e, 0x23, 0x6d, 0xf9, 0x5a, 0xc3, 0x8b, 0x03, 0x88, + 0xfb, 0xcf, 0x26, 0xed, 0x70, 0x6c, 0xb8, 0xba, 0x69, 0x4c, 0x5c, 0xcb, 0x1e, 0xd1, 0xa9, 0x5b, + 0xd6, 0x14, 0x8a, 0x79, 0x3c, 0x36, 0xdc, 0x1d, 0x06, 0x47, 0xb7, 0x61, 0xd1, 0xc7, 0xb6, 0xa9, + 0xf3, 0x8b, 0x2d, 0xc1, 0x19, 0x8f, 0x7e, 0xea, 0x04, 0xba, 0x2d, 0x80, 0xc4, 0x53, 0xe7, 0x07, + 0xec, 0x03, 0xc3, 0xe5, 0x53, 0x71, 0x86, 0xa7, 0xce, 0xe8, 0xb6, 0x0d, 0x97, 0xac, 0x38, 0xac, + 0xd3, 0x49, 0x99, 0xda, 0x39, 0x65, 0xd8, 0xd8, 0x90, 0x22, 0x8b, 0x90, 0xb7, 0x4c, 0x1a, 0x2d, + 0x55, 0xb4, 0xbc, 0x65, 0xa2, 0x2f, 0xa0, 0xce, 0x8f, 0xc0, 0xc7, 0x44, 0x19, 0xfd, 0xe6, 0x62, + 0xd2, 0xdb, 0x95, 0x54, 0x55, 0xab, 0xb9, 0xd1, 0x87, 0x4f, 0x54, 0x87, 0x8f, 0x39, 0x1f, 0x55, + 0x16, 0x3e, 0xd5, 0xd8, 0xc0, 0xf3, 0x21, 0xfd, 0x00, 0x50, 0x14, 0x61, 0xd9, 0x01, 0xf6, 0x86, + 0xc6, 0x00, 0xd3, 0x70, 0xaa, 0xa2, 0x2d, 0x85, 0x81, 0x96, 0x40, 0x90, 0x00, 0xf9, 0xc4, 0x1b, + 0xd2, 0x60, 0xaa, 0x42, 0x8f, 0x7c, 0xd0, 0x4d, 0xa8, 0x19, 0xe3, 0xb1, 0xf3, 0x9d, 0x4e, 0x94, + 0xdc, 0xf0, 0x45, 0x04, 0x45, 0x61, 0xdd, 0xef, 0xec, 0x96, 0x8f, 0xde, 0x81, 0x86, 0xc7, 0xf6, + 0x89, 0x74, 0xa1, 0x3d, 0xcb, 0xec, 0x06, 0x1e, 0x07, 0xf7, 0xa8, 0x12, 0xa9, 0xf7, 0xa1, 0x91, + 0x18, 0x5c, 0x54, 0x86, 0x22, 0x0f, 0xf8, 0xf9, 0x7d, 0x8e, 0x1c, 0xaa, 0xc2, 0x82, 0xd6, 0xee, + 0xed, 0xb5, 0xb6, 0xdb, 0x4a, 0x5e, 0xfd, 0x17, 0x05, 0xa8, 0xc7, 0x6c, 0xd8, 0x5f, 0xc2, 0x7c, + 0x99, 0x39, 0x09, 0xde, 0x81, 0x46, 0x34, 0x09, 0x74, 0xea, 0x2c, 0xb3, 0x99, 0x50, 0x0f, 0x67, + 0xc2, 0x01, 0xf1, 0x9a, 0xcf, 0x9d, 0x0d, 0x87, 0xb3, 0x67, 0xc3, 0x9d, 0x19, 0x76, 0xfb, 0x87, + 0x99, 0x12, 0xaf, 0x33, 0x5c, 0xff, 0xbb, 0x00, 0x8b, 0x71, 0x2b, 0xfe, 0x57, 0x7e, 0xbc, 0xfa, + 0xb3, 0xc7, 0xeb, 0xee, 0x2c, 0xd7, 0xe5, 0x07, 0x5a, 0xc3, 0x6e, 0x40, 0x35, 0x70, 0x02, 0x63, + 0xcc, 0xfd, 0x83, 0x2a, 0x9b, 0xa8, 0x14, 0x44, 0xbd, 0x01, 0xc2, 0x87, 0x13, 0x08, 0x9b, 0x56, + 0x63, 0x7c, 0x18, 0x8d, 0x08, 0xd2, 0x5e, 0x63, 0xe0, 0xbf, 0x82, 0x9a, 0xec, 0x34, 0xa2, 0x26, + 0x2c, 0xb0, 0x73, 0x75, 0xf1, 0xd6, 0x40, 0x7c, 0x52, 0xab, 0xca, 0xa9, 0xf4, 0x20, 0x18, 0x87, + 0x56, 0x95, 0xc3, 0xfa, 0xc1, 0x58, 0xfd, 0x83, 0x1c, 0x2c, 0xc6, 0x7d, 0x48, 0x62, 0x68, 0x13, + 0x6e, 0xa7, 0x3e, 0x18, 0x5b, 0x62, 0x4b, 0xbb, 0xac, 0xad, 0xc4, 0x7d, 0xcc, 0x6d, 0x8a, 0x43, + 0x5f, 0xc2, 0x7a, 0xba, 0xd4, 0xd4, 0x0f, 0xb0, 0x17, 0xdd, 0xa1, 0x5b, 0x4b, 0x96, 0xa4, 0xf8, + 0x8e, 0xa9, 0xfe, 0xab, 0x12, 0xf3, 0xdb, 0xff, 0xb2, 0xd4, 0x78, 0x13, 0xca, 0x13, 0xec, 0xfb, + 0xc6, 0x88, 0xef, 0xbb, 0xc4, 0x5c, 0xbb, 0x7d, 0x8e, 0xd1, 0x42, 0x9a, 0x4c, 0xb3, 0x3e, 0x7f, + 0xa1, 0x59, 0x2f, 0x9d, 0x63, 0xd6, 0x17, 0xce, 0x35, 0xeb, 0xe5, 0xc4, 0xc4, 0xb8, 0x0b, 0xa5, + 0x5f, 0x4e, 0xf1, 0x14, 0xfb, 0xdc, 0x6b, 0x96, 0x1c, 0xf3, 0xaf, 0x29, 0x5c, 0xe3, 0x78, 0x74, + 0x2f, 0x6b, 0x0a, 0x31, 0x0d, 0xbe, 0xe4, 0xc4, 0xa8, 0x5e, 0x7a, 0x62, 0xd4, 0xb2, 0x26, 0x06, + 0xbd, 0xe4, 0xe5, 0xfb, 0x96, 0x63, 0xb3, 0xe3, 0x32, 0x6a, 0x7f, 0xeb, 0x5a, 0x8d, 0x03, 0xd9, + 0x08, 0x7f, 0x0a, 0x57, 0xfc, 0xa9, 0x4b, 0xdc, 0x44, 0x6c, 0x12, 0x83, 0x6e, 0x1c, 0x59, 0x63, + 0x2b, 0x20, 0x71, 0xda, 0x22, 0xbd, 0x60, 0xb2, 0x1a, 0x62, 0xb7, 0x25, 0x24, 0xe9, 0x23, 0x12, + 0x4c, 0x31, 0xbe, 0xcc, 0x00, 0x97, 0x8f, 0x46, 0x7c, 0xf1, 0xfb, 0x5d, 0xa8, 0x1a, 0xe6, 0xc4, + 0x12, 0xd5, 0x2a, 0xc9, 0xc3, 0x83, 0x50, 0xbf, 0x36, 0x5b, 0x84, 0x8c, 0xc5, 0x3d, 0x60, 0x84, + 0xbf, 0x49, 0xb8, 0x28, 0xae, 0xab, 0x51, 0x9b, 0x5c, 0xd7, 0xc2, 0x6f, 0x82, 0x33, 0x06, 0x03, + 0xec, 0x06, 0xd8, 0xe4, 0x46, 0x39, 0xfc, 0x46, 0xd7, 0x01, 0x8c, 0xe8, 0xb9, 0xcf, 0x32, 0x37, + 0xd9, 0xd1, 0x43, 0x9f, 0x65, 0x98, 0x77, 0xa6, 0x81, 0xfe, 0x4b, 0xba, 0x8d, 0x59, 0xd7, 0x8a, + 0xce, 0x34, 0xf8, 0x1a, 0xad, 0xc0, 0xfc, 0x70, 0xec, 0xb8, 0x7e, 0x73, 0x95, 0x02, 0xd9, 0x87, + 0x7a, 0x0f, 0x20, 0x12, 0x0e, 0x95, 0x20, 0xff, 0xb4, 0xc7, 0x6e, 0x67, 0xee, 0x74, 0x7f, 0x76, + 0xa0, 0xe4, 0x10, 0x40, 0xa9, 0xf7, 0xf8, 0xb9, 0xbe, 0xdd, 0x57, 0xf2, 0xea, 0xdf, 0x80, 0xb2, + 0xd0, 0x54, 0xf4, 0x81, 0x24, 0x3a, 0x8b, 0x0f, 0x96, 0x52, 0xfa, 0x2c, 0xb5, 0xe6, 0x36, 0x14, + 0x7d, 0x71, 0x3d, 0x32, 0x93, 0x94, 0xa2, 0xd5, 0x3f, 0xcd, 0xc1, 0x02, 0x87, 0x20, 0x15, 0x6a, + 0x07, 0xdd, 0x7e, 0xe7, 0x71, 0x67, 0xbb, 0xd5, 0xef, 0x74, 0x0f, 0x68, 0x2d, 0x45, 0x2d, 0x06, + 0x23, 0xce, 0xfd, 0xd3, 0xde, 0x4e, 0xab, 0xdf, 0xa6, 0x8c, 0x8b, 0x1a, 0xff, 0x42, 0x08, 0x8a, + 0xdd, 0x5e, 0xfb, 0x80, 0x5f, 0xf3, 0xa5, 0xbf, 0xd1, 0x5b, 0x50, 0xf9, 0xaa, 0xdd, 0xee, 0xb5, + 0xf6, 0x3a, 0xcf, 0xda, 0x74, 0x0a, 0x16, 0xb5, 0x08, 0x40, 0x96, 0x34, 0xad, 0xfd, 0x58, 0x6b, + 0x1f, 0x3e, 0xa1, 0xd3, 0xac, 0xa8, 0x89, 0x4f, 0x52, 0x6e, 0xa7, 0x73, 0xb8, 0xdd, 0xd2, 0x76, + 0xda, 0x3b, 0x74, 0x82, 0x15, 0xb5, 0x08, 0x40, 0x7a, 0xb5, 0xdf, 0xed, 0xb7, 0xf6, 0xe8, 0xf4, + 0x2a, 0x6a, 0xec, 0x43, 0xdd, 0x82, 0x12, 0x9b, 0x25, 0x04, 0x6f, 0xd9, 0xee, 0x34, 0xe0, 0xd1, + 0x07, 0xfb, 0x20, 0x72, 0x3b, 0xd3, 0x80, 0x80, 0xf9, 0x56, 0x17, 0xfb, 0x52, 0x31, 0x94, 0x58, + 0xd8, 0x8b, 0x36, 0xa1, 0x44, 0xc2, 0x79, 0x6b, 0xc4, 0x7b, 0xf7, 0x4a, 0x32, 0x30, 0xde, 0xa6, + 0x58, 0x8d, 0x53, 0xa1, 0xf7, 0xe2, 0x57, 0xfa, 0x56, 0x93, 0xe4, 0xb1, 0x4b, 0x7d, 0x7f, 0x9a, + 0x83, 0x9a, 0xcc, 0x85, 0x4c, 0xa1, 0x81, 0x63, 0xdb, 0x78, 0x10, 0xe8, 0x1e, 0x0e, 0xbc, 0x33, + 0xd1, 0xd9, 0x1c, 0xa8, 0x11, 0x18, 0x99, 0x0b, 0x34, 0x00, 0x0a, 0xef, 0x97, 0x16, 0xb5, 0x32, + 0x01, 0x10, 0x4e, 0xc4, 0x11, 0xfd, 0x16, 0x63, 0xd7, 0x18, 0x5b, 0x27, 0x58, 0x4f, 0x5c, 0xb3, + 0x5e, 0x0a, 0x31, 0x1d, 0x8e, 0x40, 0x3b, 0x70, 0x7d, 0x62, 0xd9, 0xd6, 0x64, 0x3a, 0xd1, 0x43, + 0xbd, 0x25, 0xb1, 0x5c, 0x54, 0x94, 0x8d, 0xd0, 0x5b, 0x9c, 0xaa, 0x25, 0x13, 0x09, 0x2e, 0xea, + 0x1f, 0xe7, 0xa1, 0x2a, 0x35, 0xef, 0xaf, 0x68, 0x33, 0xe8, 0x41, 0x10, 0x1e, 0x39, 0x81, 0x65, + 0x90, 0xc5, 0x29, 0x12, 0x8e, 0x29, 0x22, 0x8a, 0x70, 0x4f, 0x84, 0x98, 0xd1, 0x0d, 0x60, 0xa6, + 0x90, 0x59, 0x37, 0x80, 0x99, 0x42, 0x86, 0xdf, 0xea, 0xff, 0xc9, 0x41, 0x25, 0xdc, 0x26, 0x49, + 0x47, 0x17, 0xb9, 0x8c, 0xe8, 0xe2, 0x1a, 0x00, 0x23, 0x92, 0x6e, 0x3f, 0xb2, 0x98, 0xa8, 0xc7, + 0x79, 0x4c, 0x82, 0xa9, 0x6e, 0x5a, 0xfe, 0xc0, 0x39, 0xc1, 0xde, 0x19, 0x3f, 0x7a, 0xa8, 0x4d, + 0x82, 0xe9, 0x8e, 0x80, 0x11, 0x8f, 0x80, 0x58, 0x55, 0xd2, 0x9f, 0x13, 0xc7, 0x14, 0x37, 0xf1, + 0xaa, 0x1c, 0xb6, 0xef, 0x98, 0x98, 0xac, 0xf3, 0x3c, 0x3a, 0x8b, 0x5b, 0xba, 0x3a, 0x83, 0xb6, + 0xb2, 0x6f, 0x49, 0x97, 0xc4, 0x8d, 0x64, 0x71, 0x4b, 0x9a, 0x18, 0xc2, 0x60, 0xe0, 0xea, 0x13, + 0xdf, 0xe7, 0x7e, 0x5e, 0x29, 0x18, 0xb8, 0xfb, 0xbe, 0xaf, 0x3e, 0x84, 0xaa, 0xb4, 0xd5, 0x83, + 0x36, 0x61, 0x59, 0xde, 0x17, 0x8a, 0xfb, 0x1a, 0x4b, 0xd2, 0x3e, 0x10, 0x73, 0x34, 0xd4, 0x3f, + 0x29, 0x40, 0x23, 0xb1, 0xd9, 0x73, 0xbe, 0x0b, 0xc4, 0xb7, 0x8c, 0x22, 0x15, 0xab, 0x6b, 0x55, + 0x0e, 0xa3, 0xc3, 0x77, 0x03, 0xaa, 0xc7, 0x78, 0xec, 0x62, 0x4f, 0x77, 0xec, 0xb1, 0xe8, 0x36, + 0x60, 0xa0, 0xae, 0x3d, 0xa6, 0x26, 0xcd, 0xc4, 0x43, 0xec, 0x79, 0xc6, 0x98, 0x31, 0x61, 0xf7, + 0xb3, 0x6b, 0x02, 0x48, 0xb9, 0xdc, 0x87, 0x15, 0x7a, 0xab, 0x99, 0x3f, 0xe7, 0xd0, 0x85, 0x3c, + 0xec, 0x5c, 0x64, 0x59, 0xc6, 0xb5, 0xb9, 0x6c, 0xef, 0xc1, 0xd2, 0xd8, 0xb1, 0x47, 0x63, 0x7a, + 0x6b, 0x5a, 0xd0, 0x97, 0x98, 0xf9, 0x0d, 0x11, 0x82, 0xf8, 0x1e, 0x2c, 0xd1, 0x03, 0x3f, 0x9d, + 0xf6, 0x88, 0xaf, 0x87, 0x5a, 0x55, 0xd7, 0x1a, 0x14, 0x41, 0xfb, 0xd4, 0xa7, 0xb2, 0xdc, 0x83, + 0x25, 0xea, 0x4b, 0xc4, 0x5a, 0xce, 0x7c, 0x0a, 0xea, 0xa5, 0x6b, 0x52, 0xeb, 0xef, 0x70, 0xc7, + 0x9d, 0xd3, 0x46, 0xae, 0xf1, 0xa2, 0x44, 0x49, 0xec, 0x7f, 0x78, 0x76, 0x27, 0x51, 0x02, 0x3b, + 0xb3, 0xa2, 0x70, 0x89, 0x14, 0x41, 0x91, 0x6a, 0x17, 0x3b, 0xdd, 0xa4, 0xbf, 0xd5, 0x8f, 0x61, + 0x6d, 0xdf, 0x4d, 0x8c, 0x1b, 0x5f, 0xef, 0x66, 0x8e, 0x9e, 0xfa, 0x9f, 0x72, 0x70, 0x25, 0x55, + 0x8a, 0xad, 0x2e, 0xb3, 0x87, 0x5c, 0xb6, 0xe3, 0xec, 0x86, 0x47, 0x64, 0xf9, 0xe2, 0xb6, 0x9a, + 0x0f, 0xb5, 0x64, 0xab, 0x3f, 0x80, 0x65, 0x7e, 0x6b, 0xdc, 0xb3, 0x8e, 0xf4, 0x90, 0x4d, 0x51, + 0xbc, 0xe1, 0x35, 0xbb, 0x43, 0x7a, 0xba, 0x11, 0x1a, 0xd2, 0x86, 0x44, 0x4e, 0x6d, 0x2a, 0x1b, + 0xef, 0x9a, 0x20, 0x3d, 0x24, 0x2a, 0xfb, 0x9b, 0x1c, 0x2c, 0xa5, 0x9a, 0x81, 0x7e, 0x27, 0x61, + 0x54, 0x6e, 0x49, 0x76, 0x38, 0xbb, 0xa7, 0x42, 0xfb, 0xb2, 0x15, 0xb7, 0x2f, 0x37, 0xcf, 0x29, + 0x19, 0x33, 0x35, 0x2d, 0xa8, 0xf3, 0x8d, 0x4e, 0xde, 0xf5, 0xb3, 0xf6, 0xe3, 0xa4, 0xde, 0xcd, + 0xc7, 0x87, 0xe4, 0xef, 0xe5, 0xa0, 0xc6, 0x79, 0x84, 0xef, 0x1f, 0x5e, 0x8d, 0x45, 0x32, 0x76, + 0x2a, 0x5c, 0x22, 0x76, 0x2a, 0x66, 0xc5, 0x4e, 0xff, 0xb0, 0x00, 0x1b, 0x7c, 0x25, 0x19, 0xb3, + 0xa7, 0x69, 0xec, 0x64, 0x4e, 0xd8, 0xd1, 0xf7, 0x01, 0x19, 0xe3, 0xef, 0x8c, 0x33, 0x9f, 0xf8, + 0xac, 0xae, 0xe1, 0x61, 0x7d, 0x12, 0xbd, 0xc7, 0x66, 0x98, 0x6d, 0x86, 0xd8, 0xc7, 0x26, 0xba, + 0x0f, 0xab, 0xd6, 0xc8, 0x76, 0x3c, 0xe2, 0x31, 0x53, 0xc9, 0xc4, 0x8d, 0x0d, 0x7e, 0x89, 0x8d, + 0x21, 0x5b, 0x3e, 0x11, 0x91, 0xdd, 0xd2, 0x20, 0x31, 0x8f, 0x38, 0x73, 0x0f, 0xab, 0xa0, 0xd3, + 0x93, 0xc6, 0x3c, 0x4c, 0xbb, 0xd6, 0x04, 0x05, 0xaf, 0x8a, 0x0a, 0xec, 0x75, 0x4c, 0xf4, 0x05, + 0x5c, 0x0d, 0x15, 0x4f, 0xb7, 0x6c, 0x63, 0x10, 0x90, 0x55, 0x99, 0xcd, 0x6e, 0xae, 0x70, 0x6b, + 0x21, 0x41, 0x87, 0xe3, 0xd9, 0x24, 0x27, 0x3d, 0xc8, 0x3a, 0x53, 0x37, 0xac, 0x91, 0x2b, 0xce, + 0x5e, 0xf9, 0x13, 0x73, 0x6b, 0xe4, 0xa2, 0x2f, 0x60, 0x9d, 0x37, 0xc6, 0xc6, 0xa7, 0x81, 0x4e, + 0xcf, 0xee, 0x47, 0xae, 0x3e, 0xc1, 0x81, 0x67, 0x0d, 0xf8, 0x1a, 0x73, 0x85, 0x51, 0x1c, 0xe0, + 0xd3, 0xe0, 0x89, 0xe3, 0x76, 0x46, 0xee, 0x3e, 0xc5, 0xa2, 0x87, 0xb0, 0x61, 0xb2, 0x0b, 0xec, + 0xfa, 0x11, 0xf6, 0x03, 0xd6, 0x17, 0xbe, 0xe8, 0x62, 0xba, 0xe6, 0x94, 0xb5, 0x26, 0x27, 0x79, + 0x84, 0x7d, 0x7a, 0x02, 0x1a, 0x0e, 0x81, 0xfa, 0x0f, 0x0a, 0xb0, 0x9e, 0x39, 0x2a, 0x4c, 0x5d, + 0x7e, 0x3b, 0x28, 0x3f, 0xc8, 0xa0, 0xe4, 0x60, 0x35, 0x73, 0x50, 0xd0, 0xc3, 0xc4, 0x2a, 0x74, + 0x3b, 0x75, 0x20, 0x93, 0x35, 0xb7, 0xc2, 0x95, 0xe8, 0x8b, 0xf8, 0x4a, 0xf4, 0xf6, 0x05, 0xa5, + 0x63, 0xab, 0xd1, 0x03, 0xb8, 0xf2, 0xd4, 0xc7, 0x74, 0x1f, 0xc3, 0x1d, 0xd3, 0xa7, 0xed, 0xfe, + 0x85, 0x16, 0xe1, 0x3e, 0xac, 0x26, 0xcb, 0x5c, 0x60, 0x0f, 0xd4, 0x5f, 0x00, 0xb4, 0x8f, 0x46, + 0x2e, 0x67, 0x7d, 0x0f, 0x96, 0xd8, 0x16, 0xeb, 0x84, 0xf3, 0x20, 0x01, 0x32, 0x2b, 0xd1, 0xa0, + 0x08, 0xc1, 0xbb, 0x45, 0x37, 0x7d, 0x27, 0xc6, 0x29, 0x75, 0x28, 0xc5, 0xed, 0x0f, 0x6a, 0xf8, + 0x39, 0x90, 0x1d, 0xfb, 0xfc, 0x3e, 0x54, 0xda, 0x61, 0x10, 0xfa, 0xc6, 0xb9, 0xeb, 0x50, 0x24, + 0xdc, 0xd1, 0xfb, 0x89, 0x61, 0x5a, 0x89, 0x9f, 0x20, 0x26, 0x46, 0x65, 0xf6, 0x93, 0xa2, 0x50, + 0x54, 0x31, 0x08, 0xf7, 0x01, 0x3a, 0x51, 0xef, 0xa4, 0x64, 0xca, 0x65, 0xc8, 0xf4, 0x11, 0x54, + 0x3a, 0x61, 0x8b, 0x2f, 0x55, 0x42, 0x87, 0x62, 0xe7, 0x82, 0x56, 0x74, 0x5e, 0xa5, 0x15, 0x9d, + 0x64, 0x2b, 0xfe, 0x3c, 0x07, 0x4a, 0x52, 0x2f, 0xd0, 0xe7, 0x89, 0xda, 0x24, 0x33, 0x99, 0xad, + 0x77, 0x61, 0xcd, 0x9f, 0xc6, 0x6b, 0xbe, 0x31, 0xbb, 0x60, 0xec, 0x0e, 0xa2, 0x0a, 0x45, 0x7c, + 0x34, 0x72, 0xd3, 0xe9, 0x29, 0x48, 0xaf, 0x6b, 0x14, 0x47, 0x68, 0x2c, 0x42, 0x93, 0x4a, 0x01, + 0xd1, 0xa1, 0x34, 0x04, 0xa7, 0x3e, 0xe2, 0x76, 0xad, 0x6f, 0x78, 0x23, 0x1c, 0xec, 0xe3, 0xc9, + 0x11, 0xf6, 0xfc, 0x63, 0x4b, 0x1a, 0xa4, 0xb8, 0x3f, 0x9a, 0x4b, 0xfb, 0xa3, 0x6a, 0x8b, 0xaf, + 0xc2, 0x49, 0x1e, 0xe1, 0xa8, 0x5d, 0xcc, 0x22, 0x5c, 0x34, 0x92, 0x3c, 0x2e, 0x5c, 0x34, 0xb2, + 0x05, 0xbf, 0xec, 0xa2, 0x91, 0x29, 0xb2, 0x18, 0xe9, 0x5f, 0xc0, 0xf5, 0x3d, 0xc7, 0x1e, 0xed, + 0x11, 0xff, 0xeb, 0x15, 0xdd, 0xc9, 0x4b, 0x04, 0x03, 0xea, 0x7f, 0xcf, 0xc1, 0xb5, 0x59, 0xfc, + 0xbf, 0x4f, 0xc7, 0x33, 0xd3, 0x65, 0x2f, 0x66, 0xbb, 0xec, 0x5f, 0xc2, 0x7a, 0x8a, 0xd6, 0xd3, + 0xf1, 0xa9, 0x6b, 0x79, 0x61, 0xc0, 0xb1, 0x96, 0x28, 0xe4, 0xb5, 0x19, 0x5a, 0xfd, 0x47, 0x39, + 0x68, 0xce, 0x6a, 0x20, 0xfa, 0x69, 0x62, 0x5c, 0xa5, 0x5d, 0xf7, 0xf3, 0x3b, 0x3d, 0x1c, 0xda, + 0x87, 0xf1, 0xa1, 0xbd, 0x73, 0x31, 0x83, 0xd8, 0xe8, 0xfe, 0xd1, 0x3c, 0x2c, 0x70, 0xef, 0x12, + 0x7d, 0x05, 0xcb, 0x13, 0x57, 0x4f, 0x9d, 0xfc, 0x33, 0xc9, 0x36, 0xce, 0x71, 0x79, 0xb5, 0xa5, + 0x49, 0xca, 0xd9, 0xfe, 0x30, 0x6c, 0x59, 0x3e, 0x79, 0x6f, 0x23, 0xe6, 0x11, 0x87, 0x0d, 0x49, + 0x5e, 0x10, 0x29, 0x5c, 0xfa, 0x82, 0xc8, 0xcf, 0x60, 0x4d, 0x04, 0xb4, 0xdc, 0xf8, 0xf1, 0x2b, + 0x66, 0x62, 0xaf, 0xf9, 0xc6, 0x05, 0x46, 0x52, 0x5b, 0xf5, 0x32, 0x4d, 0xf5, 0x13, 0x40, 0x53, + 0x1f, 0x47, 0xa6, 0x85, 0xad, 0xb7, 0xf3, 0xc9, 0x13, 0xf9, 0xe4, 0x12, 0xa5, 0x29, 0xd3, 0xe4, + 0xca, 0x98, 0x3a, 0x09, 0x2d, 0x25, 0x5b, 0x37, 0xfb, 0x24, 0x34, 0x6c, 0x5e, 0x40, 0xa7, 0xa9, + 0x3e, 0x09, 0xe7, 0x29, 0xbf, 0x35, 0x72, 0xe3, 0x82, 0xe9, 0xcc, 0x9b, 0x97, 0x5a, 0x54, 0x0c, + 0xd8, 0x20, 0x51, 0xaf, 0xce, 0xe2, 0xe1, 0xd4, 0xb8, 0xb3, 0x5b, 0x26, 0xea, 0xc5, 0x0a, 0xa5, + 0x35, 0xc7, 0xb3, 0xf4, 0x3b, 0x76, 0xa7, 0xa3, 0x72, 0x89, 0x3b, 0x1d, 0xed, 0x30, 0x93, 0x91, + 0xe4, 0x9a, 0xf0, 0x49, 0x2d, 0xa6, 0x3f, 0xff, 0x44, 0x57, 0xa1, 0x4c, 0x37, 0xc8, 0x27, 0xc6, + 0x29, 0x5f, 0x59, 0x16, 0xc8, 0xf7, 0xbe, 0x71, 0xaa, 0xee, 0xd0, 0x37, 0x84, 0x71, 0x6f, 0xe5, + 0xd5, 0xb9, 0x7c, 0x0b, 0x65, 0xc1, 0x05, 0x7d, 0x94, 0x98, 0xa9, 0xcd, 0x74, 0x33, 0x12, 0x0a, + 0xfd, 0x41, 0x7c, 0x66, 0xae, 0xa5, 0x0b, 0xc4, 0x66, 0xe2, 0x14, 0x4a, 0xfc, 0x06, 0xe5, 0x06, + 0x54, 0x2c, 0x57, 0x8f, 0xdd, 0x63, 0x29, 0x5b, 0xe2, 0x7a, 0xe5, 0x3b, 0xd0, 0x98, 0x18, 0xfe, + 0xb7, 0xdc, 0x2d, 0xd7, 0x27, 0x3c, 0x23, 0x4c, 0x5d, 0xab, 0x13, 0x30, 0x73, 0xc9, 0xf7, 0x2d, + 0x3b, 0x45, 0x67, 0x9c, 0xf2, 0xb8, 0x4f, 0xa6, 0x33, 0x4e, 0xd5, 0x3f, 0xca, 0x01, 0x44, 0x2f, + 0xe6, 0xfe, 0x82, 0xcf, 0x1a, 0x09, 0x6c, 0x6c, 0xf9, 0x01, 0xbd, 0xd8, 0x5f, 0xd1, 0xe8, 0x6f, + 0xfa, 0x52, 0x2b, 0x7e, 0x9f, 0x52, 0x49, 0xaa, 0xbd, 0x74, 0x89, 0x72, 0x17, 0xca, 0xfb, 0x46, + 0x30, 0x38, 0x26, 0xc2, 0xdc, 0x89, 0x09, 0x23, 0xb9, 0x23, 0x94, 0xe2, 0x82, 0x17, 0x96, 0xcf, + 0xa0, 0x16, 0x0b, 0x53, 0x36, 0x63, 0xcc, 0xa4, 0xe9, 0x2b, 0x53, 0x49, 0x3c, 0xaf, 0x40, 0x49, + 0x0a, 0x7d, 0xea, 0x1a, 0xff, 0x52, 0xff, 0xcb, 0x3c, 0xc0, 0xb6, 0x63, 0x9b, 0x16, 0x5b, 0x23, + 0xee, 0x03, 0x7f, 0xd3, 0xaf, 0x47, 0xcf, 0x14, 0x51, 0x42, 0xd2, 0x43, 0x1c, 0x68, 0x15, 0x46, + 0x45, 0x9a, 0xf5, 0x29, 0xd4, 0xc2, 0xc3, 0x2d, 0x52, 0x28, 0x3f, 0xb3, 0x50, 0x78, 0x7f, 0x9c, + 0x14, 0xfb, 0x31, 0x2c, 0x26, 0x62, 0xb2, 0x42, 0x72, 0x6f, 0x5c, 0x6e, 0x8a, 0x56, 0x33, 0xe4, + 0xe6, 0x3f, 0x80, 0xaa, 0x28, 0x4d, 0xea, 0x2c, 0xce, 0x16, 0x94, 0x15, 0x23, 0x35, 0x7e, 0x16, + 0xe6, 0x51, 0x09, 0xce, 0x68, 0xa9, 0xf9, 0x99, 0xa5, 0x6a, 0x21, 0x21, 0x29, 0xf8, 0x13, 0x58, + 0x22, 0x01, 0x57, 0xbc, 0x70, 0x69, 0x66, 0xe1, 0x06, 0x3e, 0x0d, 0xb6, 0xe5, 0xf2, 0x37, 0xa0, + 0xea, 0xb9, 0xdf, 0x5a, 0x64, 0x29, 0x9a, 0x8e, 0x03, 0xba, 0xcc, 0xcd, 0x6b, 0xe0, 0xb1, 0x07, + 0xd5, 0xd3, 0x71, 0x80, 0x1e, 0x02, 0x44, 0xaf, 0xa4, 0xf9, 0x89, 0xb5, 0x74, 0xf4, 0x14, 0x8d, + 0x0f, 0x5f, 0x11, 0xc9, 0xb0, 0x56, 0xc2, 0x47, 0xd4, 0xe8, 0x11, 0x2c, 0x8f, 0xc9, 0x6a, 0x98, + 0x90, 0xb0, 0x32, 0x53, 0xc2, 0x25, 0x4a, 0x1e, 0x93, 0xf1, 0x0e, 0x28, 0x51, 0x54, 0x69, 0xeb, + 0x54, 0xed, 0x81, 0xaa, 0x7d, 0xdd, 0xe6, 0xc1, 0xa4, 0xbd, 0x47, 0xf4, 0xff, 0x23, 0xa8, 0x8a, + 0x7b, 0x70, 0xba, 0x65, 0xd3, 0xeb, 0x37, 0x8b, 0xf2, 0x14, 0x78, 0x4c, 0xb7, 0x6f, 0xb4, 0x0a, + 0xbf, 0x08, 0xd7, 0xb1, 0xd5, 0x63, 0xa8, 0x84, 0x62, 0xa3, 0x65, 0x68, 0x68, 0xdd, 0xa7, 0xfd, + 0xb6, 0xde, 0xff, 0xa6, 0x17, 0xbe, 0x4a, 0x59, 0x83, 0x65, 0x09, 0xd8, 0x39, 0xe8, 0xb7, 0xb5, + 0x83, 0xd6, 0x9e, 0x92, 0x4b, 0x20, 0xda, 0xcf, 0x39, 0x22, 0x8f, 0x56, 0x40, 0x91, 0x10, 0x3c, + 0xd1, 0x88, 0x3a, 0x84, 0x46, 0xd8, 0xa8, 0x16, 0x4b, 0x36, 0x74, 0x3f, 0x36, 0x4f, 0xae, 0xc9, + 0x9d, 0x1a, 0x23, 0x94, 0xa6, 0xca, 0x4d, 0xa8, 0x8a, 0x8e, 0xb4, 0xc2, 0x37, 0xeb, 0x32, 0x48, + 0x3d, 0x80, 0xca, 0x3e, 0x36, 0x79, 0x0d, 0xef, 0xc5, 0x6a, 0x58, 0x93, 0x4f, 0xc3, 0xcc, 0x14, + 0xef, 0x15, 0x98, 0x3f, 0x31, 0xc6, 0x53, 0x91, 0xd2, 0x83, 0x7d, 0xa8, 0x3a, 0x34, 0x5a, 0x7e, + 0xcf, 0xc3, 0x2e, 0xb6, 0x05, 0x57, 0x05, 0x0a, 0x86, 0x6f, 0x73, 0xbf, 0x9a, 0xfc, 0x24, 0x33, + 0x98, 0x50, 0x18, 0xe1, 0x31, 0x13, 0xfb, 0x42, 0x2a, 0xd4, 0x89, 0x59, 0x1f, 0xe3, 0x61, 0xa0, + 0x4f, 0x1c, 0x3f, 0xe0, 0xde, 0x61, 0x75, 0xea, 0xe3, 0x3d, 0x3c, 0x0c, 0xf6, 0x1d, 0xfa, 0xce, + 0xab, 0xce, 0x9f, 0x5a, 0x70, 0xf6, 0xe7, 0xa6, 0x47, 0xf0, 0xf1, 0x78, 0xc8, 0x3d, 0x50, 0xfa, + 0x5b, 0xbd, 0x03, 0x8d, 0x3d, 0x7a, 0x50, 0xe0, 0xe1, 0x21, 0x67, 0x10, 0x36, 0x84, 0x1f, 0x85, + 0xb1, 0x86, 0xfc, 0xd7, 0x02, 0x2c, 0x30, 0x02, 0x3f, 0xba, 0xb0, 0x69, 0xb0, 0x3d, 0x86, 0xd4, + 0x1a, 0x4c, 0x95, 0x82, 0x51, 0xf3, 0x0b, 0x9b, 0x9c, 0xf7, 0x67, 0x50, 0x89, 0x4e, 0x89, 0xf3, + 0xc9, 0x9b, 0x9a, 0x89, 0x81, 0xd3, 0x22, 0x5a, 0x74, 0x1b, 0x0a, 0x13, 0xee, 0x1e, 0xc7, 0xe2, + 0xbd, 0x70, 0x24, 0x34, 0x82, 0x47, 0x9f, 0x03, 0x90, 0xc5, 0x83, 0xf5, 0x37, 0x5f, 0x3b, 0xae, + 0xc6, 0x96, 0x1d, 0x79, 0x28, 0xe8, 0x12, 0xc2, 0x00, 0xe8, 0x27, 0x50, 0x8f, 0xad, 0x04, 0x7c, + 0x09, 0x39, 0x47, 0xba, 0x9a, 0xbc, 0x18, 0xa0, 0xfb, 0xb0, 0xc0, 0xdf, 0xc2, 0xf0, 0xf5, 0x43, + 0x52, 0x97, 0xd8, 0x00, 0x69, 0x82, 0x8e, 0x08, 0xcb, 0x8f, 0x6d, 0x3c, 0x3c, 0xe4, 0x2e, 0xd2, + 0x55, 0xd9, 0x8b, 0x89, 0x8d, 0x8b, 0x38, 0xd1, 0xf1, 0xf0, 0x10, 0x3d, 0x82, 0x46, 0x62, 0x59, + 0xe0, 0x4e, 0xd0, 0x39, 0xe2, 0x2e, 0xc6, 0x57, 0x06, 0xf5, 0x57, 0x39, 0xa8, 0x84, 0x8f, 0x53, + 0x43, 0xc3, 0x94, 0x93, 0x6c, 0xe4, 0x27, 0x00, 0x83, 0x70, 0x7d, 0xe2, 0xa3, 0xb5, 0x92, 0xb5, + 0x76, 0x69, 0x12, 0x1d, 0x7a, 0x0f, 0x16, 0x98, 0x5a, 0xf8, 0x7c, 0xb4, 0xe4, 0xbb, 0xb4, 0x0c, + 0xa1, 0x09, 0x0a, 0xf5, 0x6b, 0x28, 0x71, 0xdf, 0x38, 0x4b, 0x80, 0xf8, 0xf3, 0xf6, 0xfc, 0xe5, + 0x9e, 0xb7, 0xff, 0x8f, 0x1c, 0x28, 0xc9, 0xab, 0xa7, 0xe8, 0x6e, 0x6c, 0x26, 0xaf, 0x24, 0x2f, + 0xa9, 0x4a, 0xd3, 0x58, 0xce, 0x06, 0x95, 0xbf, 0x44, 0x36, 0xa8, 0xac, 0xfc, 0x97, 0xf2, 0x93, + 0xef, 0xe2, 0x45, 0x4f, 0xbe, 0xd1, 0x87, 0xb0, 0x60, 0xe2, 0xa1, 0x41, 0xec, 0xc7, 0xfc, 0x79, + 0x13, 0x49, 0x50, 0xa9, 0xbf, 0xce, 0x41, 0x9d, 0x20, 0xa2, 0x74, 0x4d, 0x9f, 0x42, 0xd5, 0x64, + 0x6e, 0x0f, 0x37, 0xee, 0xb3, 0x53, 0x32, 0x80, 0x19, 0xf9, 0x50, 0x0f, 0x61, 0x89, 0xc5, 0x30, + 0x3a, 0x05, 0x5a, 0xfc, 0xbe, 0x4c, 0xb6, 0xc0, 0x0a, 0x23, 0xdd, 0x09, 0x29, 0xd5, 0xbf, 0x9f, + 0x83, 0x82, 0xe6, 0x18, 0x68, 0x11, 0xf2, 0x86, 0xd8, 0xdd, 0xc9, 0x1b, 0x3e, 0x7a, 0x0b, 0xb8, + 0x0f, 0x31, 0xc6, 0xc2, 0xe7, 0x8b, 0x00, 0x64, 0xb1, 0x9b, 0x18, 0x14, 0xc5, 0x5f, 0xb3, 0xb0, + 0x2f, 0xe9, 0x46, 0x74, 0x31, 0x76, 0x23, 0x5a, 0x3c, 0xe4, 0x98, 0x3f, 0x3f, 0x59, 0x8e, 0x7a, + 0x87, 0x3d, 0x2a, 0x72, 0x8c, 0x8b, 0x12, 0xe0, 0xb0, 0x5c, 0x1f, 0x94, 0x30, 0xca, 0xf5, 0xe1, + 0x39, 0x46, 0x46, 0xae, 0x0f, 0x42, 0x44, 0x51, 0xea, 0xbf, 0xce, 0x41, 0xe1, 0x99, 0x37, 0xcc, + 0x54, 0xd3, 0xb7, 0x21, 0xef, 0x99, 0xd2, 0xfc, 0x48, 0xdf, 0x3c, 0xcd, 0x7b, 0x26, 0xba, 0x0f, + 0x15, 0x7e, 0x61, 0xda, 0x0b, 0xf8, 0x7b, 0xd2, 0x19, 0xd7, 0x54, 0x19, 0x99, 0x46, 0x53, 0x16, + 0xf0, 0x4b, 0xda, 0x5e, 0xc0, 0x15, 0x69, 0x46, 0x11, 0x46, 0xa6, 0x05, 0xfc, 0x66, 0x2b, 0xbb, + 0x81, 0x97, 0xb7, 0x4c, 0xf5, 0x37, 0x39, 0x58, 0xd9, 0x61, 0x7a, 0x43, 0x75, 0x69, 0xc7, 0xf2, + 0x03, 0xc3, 0x1e, 0x60, 0xb4, 0x05, 0xe1, 0x56, 0x37, 0xdb, 0xc5, 0xd6, 0x4d, 0x8e, 0xe2, 0xdd, + 0xb5, 0x2a, 0xd0, 0xa9, 0x72, 0xf4, 0xd0, 0x3c, 0xa3, 0x1c, 0x1b, 0xea, 0x55, 0x81, 0x8e, 0x95, + 0x53, 0xff, 0x5d, 0x11, 0x4a, 0xec, 0x8d, 0x70, 0x4a, 0x5f, 0x36, 0xa0, 0x12, 0x6d, 0xc3, 0xf3, + 0x6c, 0x70, 0x9e, 0xd8, 0x77, 0xbf, 0x01, 0x55, 0xe2, 0xb1, 0x60, 0x9b, 0x9d, 0x26, 0x17, 0x98, + 0x87, 0xc5, 0x40, 0xf4, 0x34, 0xf9, 0x5d, 0x50, 0x38, 0x01, 0xb7, 0x73, 0x7c, 0xd2, 0x55, 0xb4, + 0x06, 0x83, 0xb7, 0x04, 0x38, 0xf6, 0xec, 0x63, 0x3e, 0xf1, 0xec, 0xe3, 0xfd, 0xcc, 0x10, 0x9a, + 0x9f, 0xb9, 0xa6, 0xc2, 0xe4, 0x5f, 0xcc, 0x8e, 0xe4, 0x17, 0x5e, 0x65, 0xb3, 0x7c, 0x46, 0x3c, + 0xdf, 0x87, 0x2b, 0x7c, 0xb2, 0x27, 0xfb, 0x98, 0x2d, 0xf3, 0xd7, 0x63, 0x53, 0x3b, 0x35, 0xb8, + 0xda, 0x8a, 0x99, 0x35, 0xe4, 0x0f, 0xe9, 0xb5, 0x8b, 0x21, 0x36, 0xb1, 0xc7, 0x9e, 0xcc, 0x56, + 0x92, 0x86, 0x6a, 0x5b, 0x46, 0x6b, 0x71, 0xea, 0x37, 0xf4, 0xd8, 0x22, 0xb9, 0x7b, 0x52, 0xbd, + 0xec, 0xee, 0x89, 0xea, 0x40, 0x3d, 0x26, 0xdf, 0x39, 0xfb, 0x6d, 0xf1, 0xd7, 0xa6, 0xf9, 0xd4, + 0x6b, 0xd3, 0xb7, 0x61, 0x91, 0x6d, 0x4e, 0xe8, 0x86, 0xaf, 0x87, 0x71, 0x60, 0x5d, 0xab, 0x31, + 0x68, 0xcb, 0x27, 0xfe, 0xb0, 0xfa, 0x67, 0x39, 0xa8, 0xd0, 0x67, 0x74, 0x1d, 0x7b, 0xe8, 0x7c, + 0x2f, 0x2f, 0xf8, 0xee, 0x40, 0xc3, 0x9e, 0x4e, 0x74, 0xe9, 0xf5, 0x24, 0xbf, 0x88, 0xb2, 0x68, + 0x4f, 0x27, 0xf2, 0xeb, 0xd3, 0xab, 0x50, 0xb6, 0xf9, 0x3e, 0xba, 0xb8, 0xf7, 0x64, 0xb3, 0x2d, + 0x74, 0x74, 0x0b, 0x6a, 0x04, 0x15, 0x5e, 0x42, 0x63, 0x37, 0x4d, 0xaa, 0xf6, 0x74, 0xd2, 0xe2, + 0x20, 0xf5, 0xc7, 0x34, 0x17, 0x80, 0x66, 0x1d, 0x91, 0x86, 0x88, 0xe5, 0x51, 0x3c, 0x3c, 0x4b, + 0xa5, 0x42, 0x09, 0x9b, 0xcc, 0xde, 0xfe, 0xa8, 0x0f, 0x69, 0x42, 0xeb, 0xb0, 0x34, 0x5f, 0x33, + 0x2f, 0x5d, 0xdc, 0xa5, 0xe9, 0x66, 0xb6, 0x9d, 0x31, 0x7f, 0x88, 0x34, 0x33, 0xa1, 0xd4, 0x1a, + 0x2c, 0x98, 0x47, 0xba, 0xd4, 0x77, 0x25, 0xf3, 0x88, 0xde, 0x0c, 0xde, 0x84, 0x65, 0xfa, 0x8c, + 0x53, 0xa7, 0xf9, 0x24, 0x93, 0xb7, 0x7d, 0x28, 0x6a, 0x67, 0x3a, 0x71, 0xc3, 0xeb, 0x46, 0x2c, + 0x2d, 0x8d, 0x54, 0x23, 0x7f, 0x71, 0xb8, 0x04, 0x0d, 0x91, 0x0a, 0x54, 0xa4, 0x1e, 0x40, 0xa0, + 0x44, 0x20, 0x46, 0x76, 0xef, 0x0f, 0x0a, 0x50, 0x62, 0xa1, 0x0e, 0xaa, 0x41, 0x59, 0x6b, 0x1f, + 0xb6, 0xb5, 0x67, 0xed, 0x1d, 0x65, 0x0e, 0x01, 0x14, 0x3b, 0xbd, 0x93, 0x4f, 0x94, 0x97, 0x2f, + 0x8a, 0xfc, 0xf7, 0x96, 0xf2, 0xf2, 0x45, 0x19, 0xd5, 0x61, 0x81, 0xc0, 0xf5, 0xfd, 0x6d, 0xe5, + 0x57, 0x2f, 0x8a, 0xfc, 0x73, 0x8b, 0x7d, 0x96, 0x51, 0x03, 0x2a, 0x0c, 0xdb, 0xdb, 0x3b, 0x54, + 0xfe, 0xf0, 0x45, 0x91, 0x03, 0xb6, 0x04, 0xa0, 0x8c, 0x16, 0xa1, 0x4c, 0x29, 0x9e, 0xf5, 0x0e, + 0x94, 0x17, 0x2f, 0x8b, 0xfc, 0x7b, 0x8b, 0x7f, 0x97, 0xd1, 0x12, 0x54, 0x05, 0x9e, 0x30, 0x7d, + 0xf9, 0xb2, 0xc8, 0x41, 0x5b, 0x11, 0xa8, 0x4c, 0x24, 0x7a, 0x46, 0x38, 0xfe, 0x87, 0x17, 0x26, + 0xf9, 0xdd, 0x26, 0xa5, 0xff, 0xec, 0x85, 0x89, 0x2a, 0x50, 0xd0, 0xfa, 0xdb, 0xca, 0x1f, 0xbe, + 0x2c, 0x22, 0x05, 0x80, 0x32, 0x6a, 0x1f, 0x6c, 0xb7, 0x7a, 0xca, 0xdf, 0x7d, 0x21, 0x20, 0x5b, + 0x21, 0xa4, 0x8c, 0x56, 0x60, 0xf1, 0xf1, 0x5e, 0xf7, 0x67, 0xfa, 0x61, 0xaf, 0xbd, 0xad, 0xd3, + 0xe6, 0xfe, 0xfa, 0x65, 0x31, 0x05, 0xdd, 0x52, 0x7e, 0xfd, 0xb2, 0x8c, 0x9a, 0x80, 0xe2, 0xb4, + 0x54, 0xe4, 0xdf, 0xbc, 0x2c, 0xa6, 0x30, 0x5b, 0x1c, 0x53, 0x46, 0x57, 0x40, 0x89, 0x30, 0x7b, + 0x0f, 0x38, 0xdc, 0x44, 0x8b, 0x50, 0xea, 0xf6, 0x5a, 0x5f, 0x3f, 0x6d, 0x2b, 0xff, 0xeb, 0xe5, + 0x9f, 0xbc, 0x28, 0xde, 0xdb, 0x86, 0xb2, 0x98, 0x58, 0x08, 0xa0, 0xb4, 0xbb, 0xd7, 0x7d, 0xd4, + 0xda, 0x53, 0xe6, 0xa2, 0xe4, 0x93, 0xf4, 0xce, 0x63, 0x6b, 0xe7, 0xf7, 0xf4, 0xce, 0x81, 0x92, + 0x47, 0x55, 0x58, 0x20, 0xbf, 0xbb, 0x4f, 0xfb, 0x2c, 0x2b, 0xe5, 0x33, 0xed, 0xb1, 0x52, 0xbc, + 0xb7, 0x17, 0x7b, 0xf7, 0xcb, 0x56, 0x57, 0xa4, 0x40, 0x6d, 0xaf, 0xdb, 0xfd, 0xea, 0x69, 0x4f, + 0x6f, 0x3f, 0x6f, 0x6d, 0xf7, 0x95, 0x39, 0xb4, 0x04, 0x75, 0x0e, 0xd9, 0xeb, 0x1e, 0xec, 0xb6, + 0x35, 0x25, 0x87, 0x10, 0x2c, 0x72, 0xd0, 0xe1, 0x93, 0xae, 0xd6, 0x6f, 0x6b, 0x4a, 0xfe, 0xde, + 0xaf, 0xe8, 0x93, 0xf0, 0x70, 0x77, 0x89, 0xde, 0xb9, 0xd4, 0xda, 0x8f, 0x3b, 0xcf, 0x95, 0x39, + 0xa2, 0x29, 0x07, 0xed, 0xce, 0xee, 0x93, 0x47, 0x5d, 0x52, 0x7a, 0x01, 0x0a, 0xfd, 0xd6, 0x2e, + 0x17, 0xeb, 0x50, 0xef, 0xb5, 0xfa, 0x4f, 0x94, 0x02, 0xaa, 0x43, 0x65, 0xbb, 0xbb, 0xbf, 0xff, + 0xf4, 0xa0, 0xd3, 0xff, 0x46, 0x21, 0x63, 0x58, 0x6f, 0x3f, 0xef, 0xeb, 0x11, 0x68, 0x9e, 0x84, + 0xd0, 0x7b, 0x2d, 0x6d, 0xb7, 0x2d, 0x01, 0x4b, 0x8c, 0xf5, 0xf3, 0xbe, 0xfe, 0xa4, 0xdb, 0x53, + 0x16, 0xee, 0xbd, 0x0b, 0x95, 0x70, 0x53, 0x89, 0x5e, 0x03, 0x3f, 0xf8, 0x46, 0xbe, 0x0f, 0x0e, + 0x50, 0xea, 0x1c, 0x3c, 0x6b, 0x6b, 0x7d, 0x25, 0x7f, 0xef, 0x1e, 0x28, 0xc9, 0x2d, 0x23, 0x54, + 0x82, 0x7c, 0xfb, 0x6b, 0x65, 0x8e, 0xfc, 0xdd, 0x6d, 0x2b, 0x39, 0xf2, 0x77, 0xaf, 0xad, 0xe4, + 0xef, 0x7d, 0xc8, 0xaf, 0x5e, 0xf1, 0x38, 0x2d, 0xba, 0x69, 0x4e, 0x3a, 0x79, 0x7b, 0xbb, 0xdd, + 0xeb, 0x33, 0xe6, 0x5a, 0xfb, 0xf7, 0xda, 0xdb, 0x84, 0xf9, 0x53, 0x58, 0xce, 0x88, 0xb3, 0x49, + 0xa3, 0x42, 0xd9, 0xf5, 0xd6, 0x0e, 0x99, 0x36, 0x2b, 0xa0, 0x44, 0x20, 0xad, 0xbd, 0xdf, 0x7d, + 0x46, 0x2a, 0x5e, 0x85, 0x25, 0x19, 0xca, 0xaf, 0xb0, 0xdf, 0xfb, 0x00, 0xea, 0xb1, 0xe0, 0x9a, + 0xf4, 0xe0, 0x7e, 0x7b, 0x47, 0xdf, 0xef, 0x12, 0x56, 0x0d, 0xa8, 0x92, 0x0f, 0x41, 0x9e, 0xbb, + 0xf7, 0x3e, 0x40, 0xe4, 0xc1, 0x87, 0xe9, 0x87, 0x49, 0x27, 0xec, 0xf7, 0xba, 0x1a, 0x97, 0xb9, + 0xfd, 0x9c, 0xfe, 0xce, 0x3f, 0xf8, 0x8f, 0xb7, 0xa1, 0xbc, 0x4b, 0xd6, 0xa9, 0x96, 0x6b, 0xa1, + 0x3d, 0xa8, 0x4a, 0x19, 0x4a, 0xd0, 0x5b, 0xb1, 0xb8, 0x22, 0x91, 0xf8, 0x64, 0xfd, 0xda, 0x0c, + 0x2c, 0x5f, 0x59, 0xe6, 0x50, 0x07, 0x20, 0xca, 0x61, 0x82, 0x36, 0x64, 0xf2, 0x44, 0xba, 0x93, + 0xf5, 0xb7, 0xb2, 0x91, 0x21, 0xab, 0xc7, 0x50, 0x09, 0x33, 0xb7, 0x20, 0x69, 0xfb, 0x2f, 0x99, + 0xe2, 0x65, 0x7d, 0x23, 0x13, 0x17, 0xf2, 0xd9, 0x83, 0xaa, 0x94, 0xca, 0x5d, 0x6e, 0x60, 0x3a, + 0x37, 0xbc, 0xdc, 0xc0, 0xac, 0xfc, 0xef, 0x73, 0xe8, 0x29, 0x2c, 0xc6, 0x93, 0xb8, 0xa3, 0x1b, + 0xb2, 0x13, 0x92, 0x91, 0x1b, 0x7e, 0xfd, 0xe6, 0x6c, 0x02, 0x99, 0x6d, 0x3c, 0x37, 0xbb, 0xcc, + 0x36, 0x33, 0x37, 0xbc, 0xcc, 0x36, 0x3b, 0xad, 0x3b, 0x6b, 0xbb, 0xf4, 0x8f, 0x12, 0xe4, 0xb6, + 0xa7, 0xff, 0x37, 0x83, 0xdc, 0xf6, 0x8c, 0xff, 0xae, 0xa0, 0xce, 0x21, 0x0d, 0xea, 0xb1, 0xbc, + 0xd5, 0xe8, 0x7a, 0xcc, 0xfa, 0xa7, 0x39, 0xde, 0x98, 0x89, 0x0f, 0x79, 0xfe, 0x75, 0x58, 0x4a, + 0xe5, 0xc3, 0x46, 0xea, 0xc5, 0x79, 0xb9, 0xd7, 0x7f, 0x74, 0x2e, 0x4d, 0xc8, 0xff, 0xaf, 0x45, + 0x96, 0x2d, 0x64, 0x2f, 0xdd, 0x23, 0x9b, 0x91, 0x6e, 0x7b, 0x5d, 0x3d, 0x8f, 0x44, 0x1e, 0xb5, + 0x78, 0x16, 0x6c, 0x79, 0xd4, 0x32, 0x53, 0x6a, 0xcb, 0xa3, 0x36, 0x23, 0x81, 0xf6, 0x1c, 0x7a, + 0x0e, 0x8d, 0x44, 0xa2, 0x6b, 0x24, 0xeb, 0x50, 0x66, 0x76, 0xed, 0xf5, 0x5b, 0xe7, 0x50, 0x84, + 0x9c, 0x1f, 0x42, 0x89, 0xf9, 0x30, 0x68, 0x2d, 0x36, 0xd8, 0x51, 0xfa, 0x83, 0xf5, 0x66, 0x1a, + 0x11, 0x16, 0xff, 0x0c, 0x16, 0x78, 0x3e, 0x07, 0x14, 0x27, 0x93, 0x52, 0x3c, 0xac, 0x27, 0x52, + 0x7f, 0xa8, 0x73, 0x1f, 0xe5, 0x88, 0x1e, 0x4a, 0xb9, 0x0f, 0x64, 0x3d, 0x4c, 0x27, 0x60, 0x90, + 0xf5, 0x30, 0x2b, 0x61, 0xc2, 0x1c, 0xfa, 0x29, 0x2c, 0xf0, 0x13, 0x19, 0x94, 0x3e, 0xd5, 0x11, + 0x5c, 0xae, 0x66, 0x60, 0xe4, 0x65, 0x2a, 0xfa, 0x77, 0x11, 0xf2, 0x32, 0x95, 0xfa, 0x87, 0x17, + 0xf2, 0x32, 0x95, 0xf1, 0x1f, 0x26, 0xe6, 0xd0, 0x0e, 0x40, 0x94, 0x88, 0x59, 0x66, 0x95, 0x4a, + 0xcf, 0xbc, 0x9e, 0x9d, 0x35, 0x84, 0x76, 0xd0, 0x97, 0x61, 0xf2, 0xe9, 0xe8, 0x95, 0x8f, 0xe4, + 0x4c, 0x86, 0xff, 0xaf, 0x64, 0x3d, 0xf1, 0x3f, 0x20, 0x68, 0xe1, 0xc7, 0x50, 0x09, 0xb3, 0x81, + 0xcb, 0x2b, 0x65, 0x32, 0x17, 0xb9, 0xbc, 0x52, 0xa6, 0xd3, 0x87, 0xb3, 0x5e, 0x09, 0x73, 0x85, + 0xc7, 0x7a, 0x25, 0x99, 0x56, 0x3c, 0xd6, 0x2b, 0xe9, 0xf4, 0xe2, 0x73, 0xe8, 0x09, 0x54, 0xc2, + 0xfc, 0xde, 0xb2, 0x48, 0xc9, 0xac, 0xe3, 0xb2, 0x48, 0xe9, 0x84, 0xe0, 0x73, 0x77, 0x73, 0x44, + 0x65, 0x59, 0x46, 0x6d, 0xb4, 0x36, 0x23, 0xa1, 0xf7, 0x7a, 0x33, 0x8d, 0x90, 0xad, 0x48, 0x98, + 0x3c, 0x5b, 0x16, 0x24, 0x99, 0x93, 0x7b, 0x7d, 0x23, 0x13, 0x27, 0xeb, 0x1c, 0x4f, 0x17, 0x9c, + 0x50, 0x7d, 0x29, 0xcf, 0xac, 0xac, 0x73, 0x89, 0xdc, 0xc2, 0xa1, 0xd6, 0x26, 0x39, 0xc4, 0xd3, + 0x08, 0x27, 0xb4, 0x36, 0xc1, 0x21, 0xd4, 0x5a, 0xca, 0x24, 0x25, 0xb0, 0xcc, 0xe7, 0xad, 0x6c, + 0xa4, 0xcc, 0x2a, 0xca, 0xe4, 0x8b, 0x52, 0x7a, 0x31, 0x83, 0x55, 0x46, 0xf2, 0x5f, 0x6a, 0x63, + 0xa4, 0x74, 0xbe, 0x28, 0xad, 0x19, 0x32, 0xb3, 0x6b, 0x33, 0xb0, 0xf2, 0x78, 0x85, 0xc9, 0x78, + 0xe5, 0xf1, 0x4a, 0xe6, 0xf4, 0x95, 0xc7, 0x2b, 0x9d, 0xbd, 0x97, 0xda, 0xaa, 0x58, 0x62, 0x5f, + 0xd9, 0x56, 0x65, 0xe5, 0x08, 0x96, 0x6d, 0x55, 0x76, 0x46, 0xe0, 0x70, 0xf5, 0x74, 0x8c, 0xe4, + 0xea, 0x19, 0x6e, 0xb6, 0x25, 0x57, 0xcf, 0x68, 0x73, 0x8d, 0x75, 0x94, 0x94, 0x84, 0x17, 0xa5, + 0xfa, 0x55, 0x4e, 0x34, 0x2c, 0x77, 0x54, 0x56, 0xe6, 0xde, 0x39, 0x3e, 0x2f, 0x9e, 0x79, 0xc3, + 0xc4, 0xbc, 0x88, 0x12, 0xe8, 0x26, 0xe6, 0x85, 0x9c, 0x24, 0x57, 0x9a, 0x17, 0x84, 0x43, 0x6a, + 0x5e, 0x48, 0x4c, 0x36, 0x32, 0x71, 0x89, 0x3e, 0x49, 0x88, 0x11, 0x4b, 0x2a, 0x9c, 0xe8, 0x93, + 0x78, 0x71, 0x8d, 0xee, 0x56, 0x4a, 0xe7, 0xd9, 0xd7, 0x63, 0xc4, 0xa9, 0xf4, 0xb2, 0xf2, 0x30, + 0x65, 0xe6, 0xe3, 0x65, 0x3c, 0x63, 0x79, 0x72, 0x65, 0x9e, 0x59, 0x09, 0x78, 0x65, 0x9e, 0xd9, + 0x09, 0x76, 0xa9, 0x1b, 0x91, 0xcc, 0x86, 0x2b, 0xbb, 0x11, 0x33, 0xd2, 0xef, 0xca, 0x6e, 0xc4, + 0xcc, 0x64, 0xba, 0xd4, 0x07, 0x4a, 0xa5, 0xc2, 0x95, 0x7d, 0xa0, 0x59, 0xb9, 0x76, 0x65, 0x1f, + 0x68, 0x76, 0x2e, 0xdd, 0x39, 0xd4, 0x85, 0x9a, 0x9c, 0x36, 0x17, 0xc5, 0x1d, 0xbd, 0x64, 0x86, + 0xd8, 0xf5, 0xeb, 0xb3, 0xd0, 0x32, 0x43, 0x39, 0xe1, 0x2d, 0x8a, 0x7b, 0xcd, 0xe7, 0x31, 0xcc, + 0xcc, 0x93, 0xcb, 0x3c, 0x9e, 0x78, 0x2a, 0x5b, 0x94, 0xf2, 0x9a, 0x53, 0x6c, 0x6f, 0x9d, 0x43, + 0x21, 0x0f, 0x5c, 0x32, 0x77, 0xad, 0x3c, 0x70, 0x33, 0xb2, 0xe4, 0xae, 0xab, 0xe7, 0x91, 0x24, + 0x42, 0x14, 0x7e, 0xf8, 0x10, 0x0f, 0x51, 0x62, 0x99, 0x58, 0x13, 0x21, 0x4a, 0x22, 0xed, 0x29, + 0xe5, 0x13, 0x66, 0xfa, 0x94, 0xf9, 0x24, 0x53, 0xe0, 0xca, 0x7c, 0xd2, 0x49, 0x6a, 0xe9, 0xb8, + 0xc8, 0x39, 0x3a, 0xe5, 0x71, 0xc9, 0xc8, 0x5e, 0xbb, 0x7e, 0x7d, 0x16, 0x3a, 0xee, 0xf1, 0x4b, + 0x49, 0x37, 0xe3, 0x1e, 0x7f, 0x3a, 0xe5, 0x6c, 0xdc, 0xe3, 0xcf, 0xca, 0xf1, 0x4a, 0x85, 0x94, + 0xff, 0x79, 0x8a, 0x2c, 0x64, 0xc6, 0xff, 0x70, 0x91, 0x85, 0xcc, 0xfc, 0x9f, 0x2b, 0x73, 0xc8, + 0xa4, 0xc9, 0xa2, 0x53, 0x67, 0x5d, 0x6f, 0x67, 0xf4, 0x79, 0x2a, 0x25, 0xe9, 0xfa, 0xed, 0x0b, + 0xa8, 0xe4, 0x5a, 0x32, 0xb2, 0xb1, 0xca, 0xb5, 0xcc, 0x4e, 0x03, 0x2b, 0xd7, 0x72, 0x5e, 0x4a, + 0xd7, 0x39, 0x34, 0x09, 0xff, 0xef, 0x55, 0xb2, 0xa2, 0x3b, 0xd9, 0x83, 0x95, 0xae, 0xeb, 0xee, + 0xc5, 0x84, 0x61, 0x75, 0x6e, 0x98, 0x27, 0x3a, 0x7d, 0x54, 0x38, 0x63, 0x24, 0xd3, 0x15, 0xbe, + 0x7b, 0x09, 0x4a, 0xd9, 0xf1, 0x88, 0x76, 0x51, 0xd1, 0x46, 0x32, 0xd8, 0x90, 0x76, 0x66, 0xd7, + 0xdf, 0xca, 0x46, 0x26, 0x56, 0xa1, 0x28, 0x9b, 0x55, 0x7c, 0x15, 0x4a, 0xfe, 0x3f, 0xaf, 0xc4, + 0x2a, 0x94, 0xfe, 0x4f, 0x60, 0xd2, 0x2a, 0x14, 0xf1, 0x4c, 0xad, 0x42, 0x29, 0xb6, 0xb7, 0xce, + 0xa1, 0x90, 0x39, 0x27, 0xfe, 0xdd, 0x17, 0x4a, 0x85, 0xef, 0xe7, 0x71, 0x9e, 0xf1, 0xbf, 0xc2, + 0xd4, 0x39, 0x64, 0xd0, 0x7f, 0x71, 0x97, 0x4c, 0xab, 0xf4, 0xa3, 0xb8, 0x45, 0xcb, 0xfc, 0xe7, + 0x60, 0xeb, 0x6f, 0x9f, 0x4f, 0x94, 0xe8, 0xe7, 0x70, 0x1f, 0x39, 0xd1, 0xcf, 0xc9, 0x1d, 0xed, + 0x44, 0x3f, 0xa7, 0xb7, 0x9f, 0xe7, 0xd0, 0x36, 0x94, 0x45, 0x50, 0x8d, 0xae, 0xa6, 0x03, 0x6d, + 0xc1, 0x68, 0x3d, 0x0b, 0x25, 0x98, 0x1c, 0x95, 0xe8, 0xc9, 0xdf, 0xc7, 0xff, 0x2f, 0x00, 0x00, + 0xff, 0xff, 0xaf, 0xa4, 0x81, 0xd6, 0x9a, 0x72, 0x00, 0x00, } diff --git a/vendor/github.com/osrg/gobgp/api/gobgp.proto b/vendor/github.com/osrg/gobgp/api/gobgp.proto index 2dafd351..5f25e59f 100644 --- a/vendor/github.com/osrg/gobgp/api/gobgp.proto +++ b/vendor/github.com/osrg/gobgp/api/gobgp.proto @@ -21,6 +21,8 @@ syntax = "proto3"; +import "google/protobuf/any.proto"; + package gobgpapi; // Interface exported by the server. @@ -31,6 +33,7 @@ service GobgpApi { rpc GetServer(GetServerRequest) returns (GetServerResponse) {} rpc AddNeighbor(AddNeighborRequest) returns (AddNeighborResponse) {} rpc DeleteNeighbor(DeleteNeighborRequest) returns (DeleteNeighborResponse) {} + rpc UpdateNeighbor(UpdateNeighborRequest) returns (UpdateNeighborResponse) {} rpc GetNeighbor(GetNeighborRequest) returns (GetNeighborResponse) {} rpc ResetNeighbor(ResetNeighborRequest) returns (ResetNeighborResponse) {} rpc SoftResetNeighbor(SoftResetNeighborRequest) returns (SoftResetNeighborResponse) {} @@ -73,16 +76,23 @@ service GobgpApi { rpc AddPolicy(AddPolicyRequest) returns (AddPolicyResponse) {} rpc DeletePolicy(DeletePolicyRequest) returns (DeletePolicyResponse) {} rpc ReplacePolicy(ReplacePolicyRequest) returns (ReplacePolicyResponse) {} + rpc UpdatePolicy(UpdatePolicyRequest) returns (UpdatePolicyResponse) {} rpc GetPolicyAssignment(GetPolicyAssignmentRequest) returns (GetPolicyAssignmentResponse) {} rpc AddPolicyAssignment(AddPolicyAssignmentRequest) returns (AddPolicyAssignmentResponse) {} rpc DeletePolicyAssignment(DeletePolicyAssignmentRequest) returns (DeletePolicyAssignmentResponse) {} rpc ReplacePolicyAssignment(ReplacePolicyAssignmentRequest) returns (ReplacePolicyAssignmentResponse) {} rpc GetRibInfo(GetRibInfoRequest) returns (GetRibInfoResponse) {} + rpc AddPeerGroup(AddPeerGroupRequest) returns (AddPeerGroupResponse) {} + rpc DeletePeerGroup(DeletePeerGroupRequest) returns (DeletePeerGroupResponse) {} + rpc UpdatePeerGroup(UpdatePeerGroupRequest) returns (UpdatePeerGroupResponse) {} + rpc AddDynamicNeighbor(AddDynamicNeighborRequest) returns (AddDynamicNeighborResponse) {} + rpc AddCollector(AddCollectorRequest) returns (AddCollectorResponse) {} + rpc Shutdown(ShutdownRequest) returns (ShutdownResponse) {} } // Constants for address families enum Family { - _ = 0; + RESERVED = 0; IPv4 = 65537; IPv6 = 131073; IPv4_MC = 65538; @@ -157,6 +167,50 @@ message DeleteNeighborRequest { message DeleteNeighborResponse { } +message UpdateNeighborRequest { + Peer peer = 1; + // Calls SoftResetIn after updating the neighbor configuration if needed. + bool do_soft_reset_in = 2; +} + +message UpdateNeighborResponse { + // Indicates whether calling SoftResetIn is required due to this update. If + // "true" is set, the client should call SoftResetIn manually. If + // "do_soft_reset_in = true" is set in the request, always returned with + // "false". + bool needs_soft_reset_in = 1; +} + +message AddPeerGroupRequest { + PeerGroup peer_group = 1; +} + +message AddPeerGroupResponse { +} + +message DeletePeerGroupRequest { + PeerGroup peer_group = 1; +} + +message DeletePeerGroupResponse { +} + +message UpdatePeerGroupRequest { + PeerGroup peer_group = 1; + bool do_soft_reset_in = 2; +} + +message UpdatePeerGroupResponse { + bool needs_soft_reset_in = 1; +} + +message AddDynamicNeighborRequest { + DynamicNeighbor dynamic_neighbor = 1; +} + +message AddDynamicNeighborResponse { +} + message ResetNeighborRequest { string address = 1; string communication = 2; @@ -201,6 +255,14 @@ message DisableNeighborRequest { message DisableNeighborResponse { } +message UpdatePolicyRequest { + repeated DefinedSet sets = 1; + repeated Policy policies = 2; +} + +message UpdatePolicyResponse { +} + message EnableMrtRequest { int32 dump_type = 1; string filename = 2; @@ -569,6 +631,24 @@ message Path { bool is_nexthop_invalid = 17; uint32 identifier = 18; uint32 local_identifier = 19; + // One of the following defined in "api/attribute.proto": + // - IPAddressPrefix + // - LabeledIPAddressPrefix + // - EncapsulationNLRI + // - EVPNEthernetAutoDiscoveryRoute + // - EVPNMACIPAdvertisementRoute + // - EVPNInclusiveMulticastEthernetTagRoute + // - EVPNEthernetSegmentRoute + // - EVPNIPPrefixRoute + // - LabeledVPNIPAddressPrefix + // - RouteTargetMembershipNLRI + // - FlowSpecNLRI + // - VPNFlowSpecNLRI + // - OpaqueNLRI + google.protobuf.Any any_nlri = 20; + // Each attribute must be one of *Attribute defined in + // "api/attribute.proto". + repeated google.protobuf.Any any_pattrs = 21; } message Destination { @@ -641,6 +721,29 @@ message Peer { AddPaths add_paths = 12; } +message PeerGroup { + // Note: Regarding to the consistency with OpenConfig model, a list of + // address family should be removed from here, and should be configured with + // the list of AfiSafi instead. + repeated uint32 families = 1; + ApplyPolicy apply_policy = 2; + PeerGroupConf conf = 3; + EbgpMultihop ebgp_multihop = 4; + RouteReflector route_reflector = 5; + PeerGroupState info = 6; + Timers timers = 7; + Transport transport = 8; + RouteServer route_server = 9; + GracefulRestart graceful_restart = 10; + repeated AfiSafi afi_safis = 11; + AddPaths add_paths = 12; +} + +message DynamicNeighbor { + string prefix = 1; + string peer_group = 2; +} + message ApplyPolicy { PolicyAssignment in_policy = 1; PolicyAssignment export_policy = 2; @@ -669,8 +772,10 @@ message PeerConf { RemovePrivateAs remove_private_as = 8; bool route_flap_damping = 9; uint32 send_community = 10; - repeated bytes remote_cap = 11; - repeated bytes local_cap = 12; + // Each attribute must be one of *Capability defined in + // "api/capability.proto". + repeated google.protobuf.Any remote_cap = 11; + repeated google.protobuf.Any local_cap = 12; string id = 13; // Note: Regarding to the consistency with OpenConfig model, list of // PrefixLimit should be removed from here, and list of PrefixLimit in @@ -683,6 +788,42 @@ message PeerConf { bool replace_peer_as = 19; } +message PeerGroupConf { + string auth_password = 1; + string description = 2; + uint32 local_as = 3; + uint32 peer_as = 5; + string peer_group_name = 6; + uint32 peer_type = 7; + enum RemovePrivateAs { + NONE = 0; + ALL = 1; + REPLACE = 2; + } + RemovePrivateAs remove_private_as = 8; + bool route_flap_damping = 9; + uint32 send_community = 10; +} + +message PeerGroupState { + string auth_password = 1; + string description = 2; + uint32 local_as = 3; + uint32 peer_as = 5; + string peer_group_name = 6; + uint32 peer_type = 7; + enum RemovePrivateAs { + NONE = 0; + ALL = 1; + REPLACE = 2; + } + RemovePrivateAs remove_private_as = 8; + bool route_flap_damping = 9; + uint32 send_community = 10; + uint32 total_paths = 11; + uint32 total_prefixes = 12; +} + message EbgpMultihop { bool enabled = 1; uint32 multihop_ttl = 2; @@ -785,6 +926,11 @@ message GracefulRestart { uint32 deferral_time = 4; bool notification_enabled = 5; bool longlived_enabled = 6; + uint32 stale_routes_time = 7; + uint32 peer_restart_time = 8; + bool peer_restarting = 9; + bool local_restarting = 10; + string mode = 11; } message MpGracefulRestartConfig { @@ -822,6 +968,7 @@ message RouteSelectionOptionsConfig { bool advertise_inactive_routes = 4; bool enable_aigp = 5; bool ignore_next_hop_igp_metric = 6; + bool disable_best_path_selection = 7; } message RouteSelectionOptionsState { @@ -831,6 +978,7 @@ message RouteSelectionOptionsState { bool advertise_inactive_routes = 4; bool enable_aigp = 5; bool ignore_next_hop_igp_metric = 6; + bool disable_best_path_selection = 7; } message RouteSelectionOptions { @@ -965,6 +1113,7 @@ enum DefinedType { COMMUNITY = 4; EXT_COMMUNITY = 5; LARGE_COMMUNITY = 6; + NEXT_HOP = 7; } message DefinedSet { @@ -1012,6 +1161,8 @@ message Conditions { } RouteType route_type = 8; MatchSet large_community_set = 9; + repeated string next_hop_in_list = 10; + repeated Family afi_safi_in = 11; } enum RouteAction { @@ -1092,6 +1243,11 @@ message PolicyAssignment { RouteAction default = 5; } +message RoutingPolicy { + repeated DefinedSet defined_set = 1; + repeated Policy policy_definition = 2; +} + message Roa { uint32 as = 1; uint32 prefixlen = 2; @@ -1110,12 +1266,29 @@ message GetRoaResponse { message Vrf { string name = 1; - bytes rd = 2; - repeated bytes import_rt = 3; - repeated bytes export_rt = 4; + // Route Distinguisher must be one of + // RouteDistinguisherTwoOctetAS, + // RouteDistinguisherIPAddressAS, + // or RouteDistinguisherFourOctetAS. + google.protobuf.Any rd = 2; + // List of the Import Route Targets. Each must be one of + // TwoOctetAsSpecificExtended, + // IPv4AddressSpecificExtended, + // or FourOctetAsSpecificExtended. + repeated google.protobuf.Any import_rt = 3; + // List of the Export Route Targets. Each must be one of + // TwoOctetAsSpecificExtended, + // IPv4AddressSpecificExtended, + // or FourOctetAsSpecificExtended. + repeated google.protobuf.Any export_rt = 4; uint32 id = 5; } +message DefaultRouteDistance { + uint32 external_route_distance = 1; + uint32 internal_route_distance = 2; +} + message Global { uint32 as = 1; string router_id = 2; @@ -1123,6 +1296,17 @@ message Global { repeated string listen_addresses = 4; repeated uint32 families = 5; bool use_multiple_paths = 6; + RouteSelectionOptionsConfig route_selection_options = 7; + DefaultRouteDistance default_route_distance = 8; + Confederation confederation = 9; + GracefulRestart graceful_restart = 10; + ApplyPolicy apply_policy = 11; +} + +message Confederation { + bool enabled = 1; + uint32 identifier = 2; + repeated uint32 member_as_list = 3; } message TableInfo { @@ -1141,3 +1325,18 @@ message GetRibInfoRequest { message GetRibInfoResponse { TableInfo info = 1; } + +message AddCollectorRequest { + string url = 1; + string db_name = 2; + uint64 table_dump_interval = 3; +} + +message AddCollectorResponse { +} + +message ShutdownRequest{ +} + +message ShutdownResponse{ +} \ No newline at end of file diff --git a/vendor/github.com/osrg/gobgp/api/grpc_server.go b/vendor/github.com/osrg/gobgp/api/grpc_server.go index 817199b5..3fa65ee5 100644 --- a/vendor/github.com/osrg/gobgp/api/grpc_server.go +++ b/vendor/github.com/osrg/gobgp/api/grpc_server.go @@ -28,6 +28,7 @@ import ( "time" farm "github.com/dgryski/go-farm" + "github.com/golang/protobuf/ptypes/any" log "github.com/sirupsen/logrus" "golang.org/x/net/context" "google.golang.org/grpc" @@ -36,6 +37,7 @@ import ( "github.com/osrg/gobgp/packet/bgp" "github.com/osrg/gobgp/server" "github.com/osrg/gobgp/table" + "github.com/osrg/gobgp/zebra" ) type Server struct { @@ -67,7 +69,7 @@ func (s *Server) Serve() error { serve := func(host string) { defer wg.Done() - lis, err := net.Listen("tcp", fmt.Sprintf(host)) + lis, err := net.Listen("tcp", host) if err != nil { log.WithFields(log.Fields{ "Topic": "grpc", @@ -239,14 +241,13 @@ func NewPeerFromConfigStruct(pconf *config.Neighbor) *Peer { if pconf.Transport.State.LocalAddress != "" { localAddress = pconf.Transport.State.LocalAddress } - var remoteCap, localCap [][]byte - for _, c := range pconf.State.RemoteCapabilityList { - cBuf, _ := c.Serialize() - remoteCap = append(remoteCap, cBuf) + remoteCap, err := MarshalCapabilities(pconf.State.RemoteCapabilityList) + if err != nil { + return nil } - for _, c := range pconf.State.LocalCapabilityList { - cBuf, _ := c.Serialize() - localCap = append(localCap, cBuf) + localCap, err := MarshalCapabilities(pconf.State.LocalCapabilityList) + if err != nil { + return nil } var removePrivateAs PeerConf_RemovePrivateAs switch pconf.Config.RemovePrivateAs { @@ -321,6 +322,75 @@ func NewPeerFromConfigStruct(pconf *config.Neighbor) *Peer { Downtime: uint64(timer.State.Downtime), }, }, + RouteReflector: &RouteReflector{ + RouteReflectorClient: pconf.RouteReflector.Config.RouteReflectorClient, + RouteReflectorClusterId: string(pconf.RouteReflector.State.RouteReflectorClusterId), + }, + RouteServer: &RouteServer{ + RouteServerClient: pconf.RouteServer.Config.RouteServerClient, + }, + GracefulRestart: &GracefulRestart{ + Enabled: pconf.GracefulRestart.Config.Enabled, + RestartTime: uint32(pconf.GracefulRestart.Config.RestartTime), + HelperOnly: pconf.GracefulRestart.Config.HelperOnly, + DeferralTime: uint32(pconf.GracefulRestart.Config.DeferralTime), + NotificationEnabled: pconf.GracefulRestart.Config.NotificationEnabled, + LonglivedEnabled: pconf.GracefulRestart.Config.LongLivedEnabled, + LocalRestarting: pconf.GracefulRestart.State.LocalRestarting, + }, + Transport: &Transport{ + RemotePort: uint32(pconf.Transport.Config.RemotePort), + LocalAddress: pconf.Transport.Config.LocalAddress, + PassiveMode: pconf.Transport.Config.PassiveMode, + }, + AfiSafis: afiSafis, + AddPaths: NewAddPathsFromConfigStruct(&pconf.AddPaths), + } +} + +func NewPeerGroupFromConfigStruct(pconf *config.PeerGroup) *PeerGroup { + families := make([]uint32, 0, len(pconf.AfiSafis)) + afiSafis := make([]*AfiSafi, 0, len(pconf.AfiSafis)) + for _, f := range pconf.AfiSafis { + families = append(families, extractFamilyFromConfigAfiSafi(&f)) + if afiSafi := NewAfiSafiFromConfigStruct(&f); afiSafi != nil { + afiSafis = append(afiSafis, afiSafi) + } + } + + timer := pconf.Timers + s := pconf.State + return &PeerGroup{ + Families: families, + ApplyPolicy: NewApplyPolicyFromConfigStruct(&pconf.ApplyPolicy), + Conf: &PeerGroupConf{ + PeerAs: pconf.Config.PeerAs, + LocalAs: pconf.Config.LocalAs, + PeerType: uint32(pconf.Config.PeerType.ToInt()), + AuthPassword: pconf.Config.AuthPassword, + RouteFlapDamping: pconf.Config.RouteFlapDamping, + Description: pconf.Config.Description, + PeerGroupName: pconf.Config.PeerGroupName, + }, + Info: &PeerGroupState{ + PeerAs: s.PeerAs, + PeerType: uint32(s.PeerType.ToInt()), + TotalPaths: s.TotalPaths, + TotalPrefixes: s.TotalPrefixes, + }, + Timers: &Timers{ + Config: &TimersConfig{ + ConnectRetry: uint64(timer.Config.ConnectRetry), + HoldTime: uint64(timer.Config.HoldTime), + KeepaliveInterval: uint64(timer.Config.KeepaliveInterval), + }, + State: &TimersState{ + KeepaliveInterval: uint64(timer.State.KeepaliveInterval), + NegotiatedHoldTime: uint64(timer.State.NegotiatedHoldTime), + Uptime: uint64(timer.State.Uptime), + Downtime: uint64(timer.State.Downtime), + }, + }, RouteReflector: &RouteReflector{ RouteReflectorClient: pconf.RouteReflector.Config.RouteReflectorClient, RouteReflectorClusterId: string(pconf.RouteReflector.Config.RouteReflectorClusterId), @@ -335,10 +405,12 @@ func NewPeerFromConfigStruct(pconf *config.Neighbor) *Peer { DeferralTime: uint32(pconf.GracefulRestart.Config.DeferralTime), NotificationEnabled: pconf.GracefulRestart.Config.NotificationEnabled, LonglivedEnabled: pconf.GracefulRestart.Config.LongLivedEnabled, + LocalRestarting: pconf.GracefulRestart.State.LocalRestarting, }, Transport: &Transport{ RemotePort: uint32(pconf.Transport.Config.RemotePort), LocalAddress: pconf.Transport.Config.LocalAddress, + PassiveMode: pconf.Transport.Config.PassiveMode, }, AfiSafis: afiSafis, AddPaths: NewAddPathsFromConfigStruct(&pconf.AddPaths), @@ -369,34 +441,29 @@ func NewValidationFromTableStruct(v *table.Validation) *RPKIValidation { } } -func ToPathApi(path *table.Path) *Path { +func toPathAPI(binNlri []byte, binPattrs [][]byte, anyNlri *any.Any, anyPattrs []*any.Any, path *table.Path, v *table.Validation) *Path { nlri := path.GetNlri() - n, _ := nlri.Serialize() - family := uint32(bgp.AfiSafiToRouteFamily(nlri.AFI(), nlri.SAFI())) - pattrs := func(arg []bgp.PathAttributeInterface) [][]byte { - ret := make([][]byte, 0, len(arg)) - for _, a := range arg { - aa, _ := a.Serialize() - ret = append(ret, aa) - } - return ret - }(path.GetPathAttrs()) + family := uint32(path.GetRouteFamily()) + vv := config.RPKI_VALIDATION_RESULT_TYPE_NONE.ToInt() + if v != nil { + vv = v.Status.ToInt() + } p := &Path{ - Nlri: n, - Pattrs: pattrs, + Nlri: binNlri, + Pattrs: binPattrs, Age: path.GetTimestamp().Unix(), IsWithdraw: path.IsWithdraw, - Validation: int32(path.ValidationStatus().ToInt()), - ValidationDetail: NewValidationFromTableStruct(path.Validation()), - Filtered: path.Filtered("") == table.POLICY_DIRECTION_IN, + Validation: int32(vv), + ValidationDetail: NewValidationFromTableStruct(v), Family: family, Stale: path.IsStale(), IsFromExternal: path.IsFromExternal(), NoImplicitWithdraw: path.NoImplicitWithdraw(), - Uuid: path.UUID().Bytes(), IsNexthopInvalid: path.IsNexthopInvalid, Identifier: nlri.PathIdentifier(), LocalIdentifier: nlri.PathLocalIdentifier(), + AnyNlri: anyNlri, + AnyPattrs: anyPattrs, } if s := path.GetSource(); s != nil { p.SourceAsn = s.AS @@ -406,6 +473,41 @@ func ToPathApi(path *table.Path) *Path { return p } +func ToPathApiInBin(path *table.Path, v *table.Validation) *Path { + nlri := path.GetNlri() + binNlri, _ := nlri.Serialize() + if path.IsWithdraw { + return toPathAPI(binNlri, nil, nil, nil, path, v) + } + binPattrs := func(attrs []bgp.PathAttributeInterface) [][]byte { + bufList := make([][]byte, 0, len(attrs)) + for _, a := range attrs { + buf, _ := a.Serialize() + bufList = append(bufList, buf) + } + return bufList + }(path.GetPathAttrs()) + return toPathAPI(binNlri, binPattrs, nil, nil, path, v) +} + +func ToPathApi(path *table.Path, v *table.Validation) *Path { + nlri := path.GetNlri() + anyNlri := MarshalNLRI(nlri) + if path.IsWithdraw { + return toPathAPI(nil, nil, anyNlri, nil, path, v) + } + anyPattrs := MarshalPathAttributes(path.GetPathAttrs()) + return toPathAPI(nil, nil, anyNlri, anyPattrs, path, v) +} + +func getValidation(v []*table.Validation, i int) *table.Validation { + if v == nil { + return nil + } else { + return v[i] + } +} + func (s *Server) GetRib(ctx context.Context, arg *GetRibRequest) (*GetRibResponse, error) { if arg == nil || arg.Table == nil { return nil, fmt.Errorf("invalid request") @@ -431,16 +533,17 @@ func (s *Server) GetRib(ctx context.Context, arg *GetRibRequest) (*GetRibRespons var in bool var err error var tbl *table.Table + var v []*table.Validation family := bgp.RouteFamily(arg.Table.Family) switch arg.Table.Type { case Resource_LOCAL, Resource_GLOBAL: - tbl, err = s.bgpServer.GetRib(arg.Table.Name, family, f()) + tbl, v, err = s.bgpServer.GetRib(arg.Table.Name, family, f()) case Resource_ADJ_IN: in = true fallthrough case Resource_ADJ_OUT: - tbl, err = s.bgpServer.GetAdjRib(arg.Table.Name, family, in, f()) + tbl, v, err = s.bgpServer.GetAdjRib(arg.Table.Name, family, in, f()) case Resource_VRF: tbl, err = s.bgpServer.GetVrfRib(arg.Table.Name, family, []*table.LookupPrefix{}) default: @@ -453,13 +556,15 @@ func (s *Server) GetRib(ctx context.Context, arg *GetRibRequest) (*GetRibRespons tblDsts := tbl.GetDestinations() dsts := make([]*Destination, 0, len(tblDsts)) + idx := 0 for _, dst := range tblDsts { dsts = append(dsts, &Destination{ Prefix: dst.GetNlri().String(), Paths: func(paths []*table.Path) []*Path { l := make([]*Path, 0, len(paths)) for i, p := range paths { - pp := ToPathApi(p) + pp := ToPathApi(p, getValidation(v, idx)) + idx++ switch arg.Table.Type { case Resource_LOCAL, Resource_GLOBAL: if i == 0 && !table.SelectionOptions.DisableBestPathSelection { @@ -496,14 +601,15 @@ func (s *Server) GetPath(arg *GetPathRequest, stream GobgpApi_GetPathServer) err family := bgp.RouteFamily(arg.Family) var tbl *table.Table var err error + var v []*table.Validation switch arg.Type { case Resource_LOCAL, Resource_GLOBAL: - tbl, err = s.bgpServer.GetRib(arg.Name, family, f()) + tbl, v, err = s.bgpServer.GetRib(arg.Name, family, f()) case Resource_ADJ_IN: in = true fallthrough case Resource_ADJ_OUT: - tbl, err = s.bgpServer.GetAdjRib(arg.Name, family, in, f()) + tbl, v, err = s.bgpServer.GetAdjRib(arg.Name, family, in, f()) case Resource_VRF: tbl, err = s.bgpServer.GetVrfRib(arg.Name, family, []*table.LookupPrefix{}) default: @@ -513,11 +619,13 @@ func (s *Server) GetPath(arg *GetPathRequest, stream GobgpApi_GetPathServer) err return err } + idx := 0 return func() error { for _, dst := range tbl.GetDestinations() { - for idx, path := range dst.GetAllKnownPathList() { - p := ToPathApi(path) - if idx == 0 && !table.SelectionOptions.DisableBestPathSelection { + for i, path := range dst.GetAllKnownPathList() { + p := ToPathApi(path, getValidation(v, idx)) + idx++ + if i == 0 && !table.SelectionOptions.DisableBestPathSelection { switch arg.Type { case Resource_LOCAL, Resource_GLOBAL: p.Best = true @@ -564,11 +672,11 @@ func (s *Server) MonitorRib(arg *MonitorRibRequest, stream GobgpApi_MonitorRibSe continue } if dst, y := dsts[path.GetNlri().String()]; y { - dst.Paths = append(dst.Paths, ToPathApi(path)) + dst.Paths = append(dst.Paths, ToPathApi(path, nil)) } else { dsts[path.GetNlri().String()] = &Destination{ Prefix: path.GetNlri().String(), - Paths: []*Path{ToPathApi(path)}, + Paths: []*Path{ToPathApi(path, nil)}, } } } @@ -579,31 +687,30 @@ func (s *Server) MonitorRib(arg *MonitorRibRequest, stream GobgpApi_MonitorRibSe } return nil } - for { - select { - case ev := <-w.Event(): - switch msg := ev.(type) { - case *server.WatchEventBestPath: - if err := sendPath(func() []*table.Path { - if len(msg.MultiPathList) > 0 { - l := make([]*table.Path, 0) - for _, p := range msg.MultiPathList { - l = append(l, p...) - } - return l - } else { - return msg.PathList + + for ev := range w.Event() { + switch msg := ev.(type) { + case *server.WatchEventBestPath: + if err := sendPath(func() []*table.Path { + if len(msg.MultiPathList) > 0 { + l := make([]*table.Path, 0) + for _, p := range msg.MultiPathList { + l = append(l, p...) } - }()); err != nil { - return err - } - case *server.WatchEventUpdate: - if err := sendPath(msg.PathList); err != nil { - return err + return l + } else { + return msg.PathList } + }()); err != nil { + return err + } + case *server.WatchEventUpdate: + if err := sendPath(msg.PathList); err != nil { + return err } } } + return nil }() } @@ -615,40 +722,38 @@ func (s *Server) MonitorPeerState(arg *Arguments, stream GobgpApi_MonitorPeerSta w := s.bgpServer.Watch(server.WatchPeerState(arg.Current)) defer func() { w.Stop() }() - for { - select { - case ev := <-w.Event(): - switch msg := ev.(type) { - case *server.WatchEventPeerState: - if len(arg.Name) > 0 && arg.Name != msg.PeerAddress.String() && arg.Name != msg.PeerInterface { - continue - } - if err := stream.Send(&Peer{ - Conf: &PeerConf{ - PeerAs: msg.PeerAS, - LocalAs: msg.LocalAS, - NeighborAddress: msg.PeerAddress.String(), - Id: msg.PeerID.String(), - NeighborInterface: msg.PeerInterface, - }, - Info: &PeerState{ - PeerAs: msg.PeerAS, - LocalAs: msg.LocalAS, - NeighborAddress: msg.PeerAddress.String(), - BgpState: msg.State.String(), - AdminState: PeerState_AdminState(msg.AdminState), - }, - Transport: &Transport{ - LocalAddress: msg.LocalAddress.String(), - LocalPort: uint32(msg.LocalPort), - RemotePort: uint32(msg.PeerPort), - }, - }); err != nil { - return err - } + for ev := range w.Event() { + switch msg := ev.(type) { + case *server.WatchEventPeerState: + if len(arg.Name) > 0 && arg.Name != msg.PeerAddress.String() && arg.Name != msg.PeerInterface { + continue + } + if err := stream.Send(&Peer{ + Conf: &PeerConf{ + PeerAs: msg.PeerAS, + LocalAs: msg.LocalAS, + NeighborAddress: msg.PeerAddress.String(), + Id: msg.PeerID.String(), + NeighborInterface: msg.PeerInterface, + }, + Info: &PeerState{ + PeerAs: msg.PeerAS, + LocalAs: msg.LocalAS, + NeighborAddress: msg.PeerAddress.String(), + BgpState: msg.State.String(), + AdminState: PeerState_AdminState(msg.AdminState), + }, + Transport: &Transport{ + LocalAddress: msg.LocalAddress.String(), + LocalPort: uint32(msg.LocalPort), + RemotePort: uint32(msg.PeerPort), + }, + }); err != nil { + return err } } } + return nil }() } @@ -686,18 +791,58 @@ func (s *Server) DisableNeighbor(ctx context.Context, arg *DisableNeighborReques return &DisableNeighborResponse{}, s.bgpServer.DisableNeighbor(arg.Address, arg.Communication) } +func (s *Server) UpdatePolicy(ctx context.Context, arg *UpdatePolicyRequest) (*UpdatePolicyResponse, error) { + rp, err := NewRoutingPolicyFromApiStruct(arg) + if err != nil { + return nil, err + } + return &UpdatePolicyResponse{}, s.bgpServer.UpdatePolicy(*rp) +} + +func NewAPIRoutingPolicyFromConfigStruct(c *config.RoutingPolicy) (*RoutingPolicy, error) { + definedSets, err := NewAPIDefinedSetsFromConfigStruct(&c.DefinedSets) + if err != nil { + return nil, err + } + policies := make([]*Policy, 0, len(c.PolicyDefinitions)) + for _, policy := range c.PolicyDefinitions { + policies = append(policies, toPolicyApi(&policy)) + } + + return &RoutingPolicy{ + DefinedSet: definedSets, + PolicyDefinition: policies, + }, nil +} + +func NewRoutingPolicyFromApiStruct(arg *UpdatePolicyRequest) (*config.RoutingPolicy, error) { + policyDefinitions := make([]config.PolicyDefinition, 0, len(arg.Policies)) + for _, p := range arg.Policies { + pd, err := NewConfigPolicyFromApiStruct(p) + if err != nil { + return nil, err + } + policyDefinitions = append(policyDefinitions, *pd) + } + + definedSets, err := NewConfigDefinedSetsFromApiStruct(arg.Sets) + if err != nil { + return nil, err + } + + return &config.RoutingPolicy{ + DefinedSets: *definedSets, + PolicyDefinitions: policyDefinitions, + }, nil +} + func (s *Server) api2PathList(resource Resource, ApiPathList []*Path) ([]*table.Path, error) { - var nlri bgp.AddrPrefixInterface - var nexthop string var pi *table.PeerInfo - var err error pathList := make([]*table.Path, 0, len(ApiPathList)) for _, path := range ApiPathList { - seen := make(map[bgp.BGPAttrType]bool) - - pattr := make([]bgp.PathAttributeInterface, 0) - extcomms := make([]bgp.ExtendedCommunityInterface, 0) + var nlri bgp.AddrPrefixInterface + var nexthop string if path.SourceAsn != 0 { pi = &table.PeerInfo{ @@ -706,69 +851,52 @@ func (s *Server) api2PathList(resource Resource, ApiPathList []*Path) ([]*table. } } - if len(path.Nlri) > 0 { - afi, safi := bgp.RouteFamilyToAfiSafi(bgp.RouteFamily(path.Family)) - if nlri, err = bgp.NewPrefixFromRouteFamily(afi, safi); err != nil { - return nil, err - } - err := nlri.DecodeFromBytes(path.Nlri) - if err != nil { - return nil, err - } - nlri.SetPathIdentifier(path.Identifier) + nlri, err := path.GetNativeNlri() + if err != nil { + return nil, err + } + nlri.SetPathIdentifier(path.Identifier) + + attrList, err := path.GetNativePathAttributes() + if err != nil { + return nil, err } - for _, attr := range path.Pattrs { - p, err := bgp.GetPathAttribute(attr) - if err != nil { - return nil, err - } - - err = p.DecodeFromBytes(attr) - if err != nil { - return nil, err - } - - if _, ok := seen[p.GetType()]; !ok { - seen[p.GetType()] = true + pattrs := make([]bgp.PathAttributeInterface, 0) + seen := make(map[bgp.BGPAttrType]struct{}) + for _, attr := range attrList { + attrType := attr.GetType() + if _, ok := seen[attrType]; !ok { + seen[attrType] = struct{}{} } else { - return nil, fmt.Errorf("the path attribute appears twice. Type : " + strconv.Itoa(int(p.GetType()))) + return nil, fmt.Errorf("duplicated path attribute type: %d", attrType) } - switch p.GetType() { - case bgp.BGP_ATTR_TYPE_NEXT_HOP: - nexthop = p.(*bgp.PathAttributeNextHop).Value.String() - case bgp.BGP_ATTR_TYPE_EXTENDED_COMMUNITIES: - value := p.(*bgp.PathAttributeExtendedCommunities).Value - if len(value) > 0 { - extcomms = append(extcomms, value...) - } - case bgp.BGP_ATTR_TYPE_MP_REACH_NLRI: - mpreach := p.(*bgp.PathAttributeMpReachNLRI) - if len(mpreach.Value) != 1 { - return nil, fmt.Errorf("include only one route in mp_reach_nlri") - } - nlri = mpreach.Value[0] - nexthop = mpreach.Nexthop.String() + + switch a := attr.(type) { + case *bgp.PathAttributeNextHop: + nexthop = a.Value.String() + case *bgp.PathAttributeMpReachNLRI: + nlri = a.Value[0] + nexthop = a.Nexthop.String() default: - pattr = append(pattr, p) + pattrs = append(pattrs, attr) } } - if nlri == nil || (!path.IsWithdraw && nexthop == "") { - return nil, fmt.Errorf("not found nlri or nexthop") + if nlri == nil { + return nil, fmt.Errorf("nlri not found") + } else if !path.IsWithdraw && nexthop == "" { + return nil, fmt.Errorf("nexthop not found") } if resource != Resource_VRF && bgp.RouteFamily(path.Family) == bgp.RF_IPv4_UC && net.ParseIP(nexthop).To4() != nil { - pattr = append(pattr, bgp.NewPathAttributeNextHop(nexthop)) + pattrs = append(pattrs, bgp.NewPathAttributeNextHop(nexthop)) } else { - pattr = append(pattr, bgp.NewPathAttributeMpReachNLRI(nexthop, []bgp.AddrPrefixInterface{nlri})) + pattrs = append(pattrs, bgp.NewPathAttributeMpReachNLRI(nexthop, []bgp.AddrPrefixInterface{nlri})) } - if len(extcomms) > 0 { - pattr = append(pattr, bgp.NewPathAttributeExtendedCommunities(extcomms)) - } - newPath := table.NewPath(pi, nlri, path.IsWithdraw, pattr, time.Now(), path.NoImplicitWithdraw) - if path.IsWithdraw == false { + newPath := table.NewPath(pi, nlri, path.IsWithdraw, pattrs, time.Now(), path.NoImplicitWithdraw) + if !path.IsWithdraw { total := bytes.NewBuffer(make([]byte, 0)) for _, a := range newPath.GetPathAttrs() { if a.GetType() == bgp.BGP_ATTR_TYPE_MP_REACH_NLRI { @@ -865,7 +993,7 @@ func (s *Server) DeleteBmp(ctx context.Context, arg *DeleteBmpRequest) (*DeleteB } func (s *Server) ValidateRib(ctx context.Context, arg *ValidateRibRequest) (*ValidateRibResponse, error) { - return &ValidateRibResponse{}, s.bgpServer.ValidateRib(arg.Prefix) + return &ValidateRibResponse{}, nil } func (s *Server) AddRpki(ctx context.Context, arg *AddRpkiRequest) (*AddRpkiResponse, error) { @@ -955,17 +1083,14 @@ func (s *Server) GetRoa(ctx context.Context, arg *GetRoaRequest) (*GetRoaRespons } func (s *Server) EnableZebra(ctx context.Context, arg *EnableZebraRequest) (*EnableZebraResponse, error) { - l := make([]config.InstallProtocolType, 0, len(arg.RouteTypes)) for _, p := range arg.RouteTypes { - if err := config.InstallProtocolType(p).Validate(); err != nil { + if _, err := zebra.RouteTypeFromString(p); err != nil { return &EnableZebraResponse{}, err - } else { - l = append(l, config.InstallProtocolType(p)) } } return &EnableZebraResponse{}, s.bgpServer.StartZebraClient(&config.ZebraConfig{ Url: arg.Url, - RedistributeRouteTypeList: l, + RedistributeRouteTypeList: arg.RouteTypes, Version: uint8(arg.Version), NexthopTriggerEnable: arg.NexthopTriggerEnable, NexthopTriggerDelay: uint8(arg.NexthopTriggerDelay), @@ -974,21 +1099,12 @@ func (s *Server) EnableZebra(ctx context.Context, arg *EnableZebraRequest) (*Ena func (s *Server) GetVrf(ctx context.Context, arg *GetVrfRequest) (*GetVrfResponse, error) { toApi := func(v *table.Vrf) *Vrf { - f := func(rts []bgp.ExtendedCommunityInterface) [][]byte { - ret := make([][]byte, 0, len(rts)) - for _, rt := range rts { - b, _ := rt.Serialize() - ret = append(ret, b) - } - return ret - } - rd, _ := v.Rd.Serialize() return &Vrf{ Name: v.Name, - Rd: rd, + Rd: MarshalRD(v.Rd), Id: v.Id, - ImportRt: f(v.ImportRt), - ExportRt: f(v.ExportRt), + ImportRt: MarshalRTs(v.ImportRt), + ExportRt: MarshalRTs(v.ExportRt), } } vrfs := s.bgpServer.GetVrf() @@ -1003,25 +1119,17 @@ func (s *Server) AddVrf(ctx context.Context, arg *AddVrfRequest) (r *AddVrfRespo if arg == nil || arg.Vrf == nil { return nil, fmt.Errorf("invalid request") } - rd := bgp.GetRouteDistinguisher(arg.Vrf.Rd) - f := func(bufs [][]byte) ([]bgp.ExtendedCommunityInterface, error) { - ret := make([]bgp.ExtendedCommunityInterface, 0, len(bufs)) - for _, rt := range bufs { - r, err := bgp.ParseExtended(rt) - if err != nil { - return nil, err - } - ret = append(ret, r) - } - return ret, nil - } - im, err := f(arg.Vrf.ImportRt) + rd, err := UnmarshalRD(arg.Vrf.Rd) if err != nil { - return &AddVrfResponse{}, err + return nil, err } - ex, err := f(arg.Vrf.ExportRt) + im, err := UnmarshalRTs(arg.Vrf.ImportRt) if err != nil { - return &AddVrfResponse{}, err + return nil, err + } + ex, err := UnmarshalRTs(arg.Vrf.ExportRt) + if err != nil { + return nil, err } return &AddVrfResponse{}, s.bgpServer.AddVrf(arg.Vrf.Name, arg.Vrf.Id, rd, im, ex) } @@ -1166,6 +1274,7 @@ func NewNeighborFromAPIStruct(a *Peer) (*config.Neighbor, error) { pconf.Config.RouteFlapDamping = a.Conf.RouteFlapDamping pconf.Config.Description = a.Conf.Description pconf.Config.PeerGroup = a.Conf.PeerGroup + pconf.Config.PeerType = config.IntToPeerTypeMap[int(a.Conf.PeerType)] pconf.Config.NeighborAddress = a.Conf.NeighborAddress pconf.Config.NeighborInterface = a.Conf.NeighborInterface pconf.Config.Vrf = a.Conf.Vrf @@ -1179,23 +1288,11 @@ func NewNeighborFromAPIStruct(a *Peer) (*config.Neighbor, error) { pconf.Config.RemovePrivateAs = config.REMOVE_PRIVATE_AS_OPTION_REPLACE } - f := func(bufs [][]byte) ([]bgp.ParameterCapabilityInterface, error) { - var caps []bgp.ParameterCapabilityInterface - for _, buf := range bufs { - c, err := bgp.DecodeCapability(buf) - if err != nil { - return nil, err - } - caps = append(caps, c) - } - return caps, nil - } - - localCaps, err := f(a.Conf.LocalCap) + localCaps, err := UnmarshalCapabilities(a.Conf.LocalCap) if err != nil { return nil, err } - remoteCaps, err := f(a.Conf.RemoteCap) + remoteCaps, err := UnmarshalCapabilities(a.Conf.RemoteCap) if err != nil { return nil, err } @@ -1282,6 +1379,7 @@ func NewNeighborFromAPIStruct(a *Peer) (*config.Neighbor, error) { pconf.GracefulRestart.Config.DeferralTime = uint16(a.GracefulRestart.DeferralTime) pconf.GracefulRestart.Config.NotificationEnabled = a.GracefulRestart.NotificationEnabled pconf.GracefulRestart.Config.LongLivedEnabled = a.GracefulRestart.LonglivedEnabled + pconf.GracefulRestart.State.LocalRestarting = a.GracefulRestart.LocalRestarting } ReadApplyPolicyFromAPIStruct(&pconf.ApplyPolicy, a.ApplyPolicy) if a.Transport != nil { @@ -1328,6 +1426,112 @@ func NewNeighborFromAPIStruct(a *Peer) (*config.Neighbor, error) { return pconf, nil } +func NewPeerGroupFromAPIStruct(a *PeerGroup) (*config.PeerGroup, error) { + pconf := &config.PeerGroup{} + if a.Conf != nil { + pconf.Config.PeerAs = a.Conf.PeerAs + pconf.Config.LocalAs = a.Conf.LocalAs + pconf.Config.AuthPassword = a.Conf.AuthPassword + pconf.Config.RouteFlapDamping = a.Conf.RouteFlapDamping + pconf.Config.Description = a.Conf.Description + pconf.Config.PeerGroupName = a.Conf.PeerGroupName + + switch a.Conf.RemovePrivateAs { + case PeerGroupConf_ALL: + pconf.Config.RemovePrivateAs = config.REMOVE_PRIVATE_AS_OPTION_ALL + case PeerGroupConf_REPLACE: + pconf.Config.RemovePrivateAs = config.REMOVE_PRIVATE_AS_OPTION_REPLACE + } + + for _, af := range a.AfiSafis { + afiSafi := config.AfiSafi{} + ReadMpGracefulRestartFromAPIStruct(&afiSafi.MpGracefulRestart, af.MpGracefulRestart) + ReadAfiSafiConfigFromAPIStruct(&afiSafi.Config, af.Config) + ReadAfiSafiStateFromAPIStruct(&afiSafi.State, af.Config) + ReadApplyPolicyFromAPIStruct(&afiSafi.ApplyPolicy, af.ApplyPolicy) + ReadRouteSelectionOptionsFromAPIStruct(&afiSafi.RouteSelectionOptions, af.RouteSelectionOptions) + ReadUseMultiplePathsFromAPIStruct(&afiSafi.UseMultiplePaths, af.UseMultiplePaths) + ReadPrefixLimitFromAPIStruct(&afiSafi.PrefixLimit, af.PrefixLimits) + ReadRouteTargetMembershipFromAPIStruct(&afiSafi.RouteTargetMembership, af.RouteTargetMembership) + ReadLongLivedGracefulRestartFromAPIStruct(&afiSafi.LongLivedGracefulRestart, af.LongLivedGracefulRestart) + ReadAddPathsFromAPIStruct(&afiSafi.AddPaths, af.AddPaths) + pconf.AfiSafis = append(pconf.AfiSafis, afiSafi) + } + // For the backward compatibility, we override AfiSafi configurations + // with Peer.Families. + for _, family := range a.Families { + found := false + for _, afiSafi := range pconf.AfiSafis { + if uint32(afiSafi.State.Family) == family { + // If Peer.Families contains the same address family, + // we enable this address family. + afiSafi.Config.Enabled = true + found = true + } + } + if !found { + // If Peer.Families does not contain the same address family, + // we append AfiSafi structure with the default value. + pconf.AfiSafis = append(pconf.AfiSafis, config.AfiSafi{ + Config: config.AfiSafiConfig{ + AfiSafiName: config.AfiSafiType(bgp.RouteFamily(family).String()), + Enabled: true, + }, + }) + } + } + } + + if a.Timers != nil { + if a.Timers.Config != nil { + pconf.Timers.Config.ConnectRetry = float64(a.Timers.Config.ConnectRetry) + pconf.Timers.Config.HoldTime = float64(a.Timers.Config.HoldTime) + pconf.Timers.Config.KeepaliveInterval = float64(a.Timers.Config.KeepaliveInterval) + pconf.Timers.Config.MinimumAdvertisementInterval = float64(a.Timers.Config.MinimumAdvertisementInterval) + } + if a.Timers.State != nil { + pconf.Timers.State.KeepaliveInterval = float64(a.Timers.State.KeepaliveInterval) + pconf.Timers.State.NegotiatedHoldTime = float64(a.Timers.State.NegotiatedHoldTime) + pconf.Timers.State.Uptime = int64(a.Timers.State.Uptime) + pconf.Timers.State.Downtime = int64(a.Timers.State.Downtime) + } + } + if a.RouteReflector != nil { + pconf.RouteReflector.Config.RouteReflectorClusterId = config.RrClusterIdType(a.RouteReflector.RouteReflectorClusterId) + pconf.RouteReflector.Config.RouteReflectorClient = a.RouteReflector.RouteReflectorClient + } + if a.RouteServer != nil { + pconf.RouteServer.Config.RouteServerClient = a.RouteServer.RouteServerClient + } + if a.GracefulRestart != nil { + pconf.GracefulRestart.Config.Enabled = a.GracefulRestart.Enabled + pconf.GracefulRestart.Config.RestartTime = uint16(a.GracefulRestart.RestartTime) + pconf.GracefulRestart.Config.HelperOnly = a.GracefulRestart.HelperOnly + pconf.GracefulRestart.Config.DeferralTime = uint16(a.GracefulRestart.DeferralTime) + pconf.GracefulRestart.Config.NotificationEnabled = a.GracefulRestart.NotificationEnabled + pconf.GracefulRestart.Config.LongLivedEnabled = a.GracefulRestart.LonglivedEnabled + pconf.GracefulRestart.State.LocalRestarting = a.GracefulRestart.LocalRestarting + } + ReadApplyPolicyFromAPIStruct(&pconf.ApplyPolicy, a.ApplyPolicy) + if a.Transport != nil { + pconf.Transport.Config.LocalAddress = a.Transport.LocalAddress + pconf.Transport.Config.PassiveMode = a.Transport.PassiveMode + pconf.Transport.Config.RemotePort = uint16(a.Transport.RemotePort) + } + if a.EbgpMultihop != nil { + pconf.EbgpMultihop.Config.Enabled = a.EbgpMultihop.Enabled + pconf.EbgpMultihop.Config.MultihopTtl = uint8(a.EbgpMultihop.MultihopTtl) + } + if a.Info != nil { + pconf.State.TotalPaths = a.Info.TotalPaths + pconf.State.TotalPrefixes = a.Info.TotalPrefixes + pconf.State.PeerAs = a.Info.PeerAs + pconf.State.PeerType = config.IntToPeerTypeMap[int(a.Info.PeerType)] + } + ReadAddPathsFromAPIStruct(&pconf.AddPaths, a.AddPaths) + return pconf, nil +} + func (s *Server) AddNeighbor(ctx context.Context, arg *AddNeighborRequest) (*AddNeighborResponse, error) { c, err := NewNeighborFromAPIStruct(arg.Peer) if err != nil { @@ -1343,6 +1547,57 @@ func (s *Server) DeleteNeighbor(ctx context.Context, arg *DeleteNeighborRequest) }}) } +func (s *Server) UpdateNeighbor(ctx context.Context, arg *UpdateNeighborRequest) (*UpdateNeighborResponse, error) { + c, err := NewNeighborFromAPIStruct(arg.Peer) + if err != nil { + return nil, err + } + needsSoftResetIn, err := s.bgpServer.UpdateNeighbor(c) + if err != nil { + return nil, err + } + if arg.DoSoftResetIn && needsSoftResetIn { + return &UpdateNeighborResponse{NeedsSoftResetIn: false}, s.bgpServer.SoftResetIn("", bgp.RouteFamily(0)) + } + return &UpdateNeighborResponse{NeedsSoftResetIn: needsSoftResetIn}, nil +} + +func (s *Server) AddPeerGroup(ctx context.Context, arg *AddPeerGroupRequest) (*AddPeerGroupResponse, error) { + c, err := NewPeerGroupFromAPIStruct(arg.PeerGroup) + if err != nil { + return nil, err + } + return &AddPeerGroupResponse{}, s.bgpServer.AddPeerGroup(c) +} + +func (s *Server) DeletePeerGroup(ctx context.Context, arg *DeletePeerGroupRequest) (*DeletePeerGroupResponse, error) { + return &DeletePeerGroupResponse{}, s.bgpServer.DeletePeerGroup(&config.PeerGroup{Config: config.PeerGroupConfig{ + PeerGroupName: arg.PeerGroup.Conf.PeerGroupName, + }}) +} + +func (s *Server) UpdatePeerGroup(ctx context.Context, arg *UpdatePeerGroupRequest) (*UpdatePeerGroupResponse, error) { + c, err := NewPeerGroupFromAPIStruct(arg.PeerGroup) + if err != nil { + return nil, err + } + needsSoftResetIn, err := s.bgpServer.UpdatePeerGroup(c) + if err != nil { + return nil, err + } + if arg.DoSoftResetIn && needsSoftResetIn { + return &UpdatePeerGroupResponse{NeedsSoftResetIn: false}, s.bgpServer.SoftResetIn("", bgp.RouteFamily(0)) + } + return &UpdatePeerGroupResponse{NeedsSoftResetIn: needsSoftResetIn}, nil +} + +func (s *Server) AddDynamicNeighbor(ctx context.Context, arg *AddDynamicNeighborRequest) (*AddDynamicNeighborResponse, error) { + return &AddDynamicNeighborResponse{}, s.bgpServer.AddDynamicNeighbor(&config.DynamicNeighbor{Config: config.DynamicNeighborConfig{ + Prefix: arg.DynamicNeighbor.Prefix, + PeerGroup: arg.DynamicNeighbor.PeerGroup, + }}) +} + func NewPrefixFromApiStruct(a *Prefix) (*table.Prefix, error) { _, prefix, err := net.ParseCIDR(a.IpPrefix) if err != nil { @@ -1360,6 +1615,17 @@ func NewPrefixFromApiStruct(a *Prefix) (*table.Prefix, error) { }, nil } +func NewConfigPrefixFromAPIStruct(a *Prefix) (*config.Prefix, error) { + _, prefix, err := net.ParseCIDR(a.IpPrefix) + if err != nil { + return nil, err + } + return &config.Prefix{ + IpPrefix: prefix.String(), + MasklengthRange: fmt.Sprintf("%d..%d", a.MaskLengthMin, a.MaskLengthMax), + }, nil +} + func NewAPIPrefixFromConfigStruct(c config.Prefix) (*Prefix, error) { min, max, err := config.ParseMaskLength(c.IpPrefix, c.MasklengthRange) if err != nil { @@ -1391,39 +1657,160 @@ func NewAPIDefinedSetFromTableStruct(t table.DefinedSet) (*DefinedSet, error) { case table.DEFINED_TYPE_NEIGHBOR: s := t.(*table.NeighborSet) c := s.ToConfig() - for _, n := range c.NeighborInfoList { - a.List = append(a.List, n) - } + a.List = append(a.List, c.NeighborInfoList...) case table.DEFINED_TYPE_AS_PATH: s := t.(*table.AsPathSet) c := s.ToConfig() - for _, n := range c.AsPathList { - a.List = append(a.List, n) - } + a.List = append(a.List, c.AsPathList...) case table.DEFINED_TYPE_COMMUNITY: s := t.(*table.CommunitySet) c := s.ToConfig() - for _, n := range c.CommunityList { - a.List = append(a.List, n) - } + a.List = append(a.List, c.CommunityList...) case table.DEFINED_TYPE_EXT_COMMUNITY: s := t.(*table.ExtCommunitySet) c := s.ToConfig() - for _, n := range c.ExtCommunityList { - a.List = append(a.List, n) - } + a.List = append(a.List, c.ExtCommunityList...) case table.DEFINED_TYPE_LARGE_COMMUNITY: s := t.(*table.LargeCommunitySet) c := s.ToConfig() - for _, n := range c.LargeCommunityList { - a.List = append(a.List, n) - } + a.List = append(a.List, c.LargeCommunityList...) default: return nil, fmt.Errorf("invalid defined type") } return a, nil } +func NewAPIDefinedSetsFromConfigStruct(t *config.DefinedSets) ([]*DefinedSet, error) { + definedSets := make([]*DefinedSet, 0) + + for _, ps := range t.PrefixSets { + prefixes := make([]*Prefix, 0) + for _, p := range ps.PrefixList { + ap, err := NewAPIPrefixFromConfigStruct(p) + if err != nil { + return nil, err + } + prefixes = append(prefixes, ap) + } + definedSets = append(definedSets, &DefinedSet{ + Type: DefinedType_PREFIX, + Name: ps.PrefixSetName, + Prefixes: prefixes, + }) + } + + for _, ns := range t.NeighborSets { + definedSets = append(definedSets, &DefinedSet{ + Type: DefinedType_NEIGHBOR, + Name: ns.NeighborSetName, + List: ns.NeighborInfoList, + }) + } + + bs := t.BgpDefinedSets + for _, cs := range bs.CommunitySets { + definedSets = append(definedSets, &DefinedSet{ + Type: DefinedType_COMMUNITY, + Name: cs.CommunitySetName, + List: cs.CommunityList, + }) + } + + for _, es := range bs.ExtCommunitySets { + definedSets = append(definedSets, &DefinedSet{ + Type: DefinedType_EXT_COMMUNITY, + Name: es.ExtCommunitySetName, + List: es.ExtCommunityList, + }) + } + + for _, ls := range bs.LargeCommunitySets { + definedSets = append(definedSets, &DefinedSet{ + Type: DefinedType_LARGE_COMMUNITY, + Name: ls.LargeCommunitySetName, + List: ls.LargeCommunityList, + }) + } + + for _, as := range bs.AsPathSets { + definedSets = append(definedSets, &DefinedSet{ + Type: DefinedType_AS_PATH, + Name: as.AsPathSetName, + List: as.AsPathList, + }) + } + + return definedSets, nil +} + +func NewConfigDefinedSetsFromApiStruct(a []*DefinedSet) (*config.DefinedSets, error) { + ps := make([]config.PrefixSet, 0) + ns := make([]config.NeighborSet, 0) + as := make([]config.AsPathSet, 0) + cs := make([]config.CommunitySet, 0) + es := make([]config.ExtCommunitySet, 0) + ls := make([]config.LargeCommunitySet, 0) + + for _, ds := range a { + if ds.Name == "" { + return nil, fmt.Errorf("empty neighbor set name") + } + switch table.DefinedType(ds.Type) { + case table.DEFINED_TYPE_PREFIX: + prefixes := make([]config.Prefix, 0, len(ds.Prefixes)) + for _, p := range ds.Prefixes { + prefix, err := NewConfigPrefixFromAPIStruct(p) + if err != nil { + return nil, err + } + prefixes = append(prefixes, *prefix) + } + ps = append(ps, config.PrefixSet{ + PrefixSetName: ds.Name, + PrefixList: prefixes, + }) + case table.DEFINED_TYPE_NEIGHBOR: + ns = append(ns, config.NeighborSet{ + NeighborSetName: ds.Name, + NeighborInfoList: ds.List, + }) + case table.DEFINED_TYPE_AS_PATH: + as = append(as, config.AsPathSet{ + AsPathSetName: ds.Name, + AsPathList: ds.List, + }) + case table.DEFINED_TYPE_COMMUNITY: + cs = append(cs, config.CommunitySet{ + CommunitySetName: ds.Name, + CommunityList: ds.List, + }) + case table.DEFINED_TYPE_EXT_COMMUNITY: + es = append(es, config.ExtCommunitySet{ + ExtCommunitySetName: ds.Name, + ExtCommunityList: ds.List, + }) + case table.DEFINED_TYPE_LARGE_COMMUNITY: + ls = append(ls, config.LargeCommunitySet{ + LargeCommunitySetName: ds.Name, + LargeCommunityList: ds.List, + }) + default: + return nil, fmt.Errorf("invalid defined type") + } + } + + return &config.DefinedSets{ + PrefixSets: ps, + NeighborSets: ns, + BgpDefinedSets: config.BgpDefinedSets{ + AsPathSets: as, + CommunitySets: cs, + ExtCommunitySets: es, + LargeCommunitySets: ls, + }, + }, nil +} + func NewDefinedSetFromApiStruct(a *DefinedSet) (table.DefinedSet, error) { if a.Name == "" { return nil, fmt.Errorf("empty neighbor set name") @@ -1474,6 +1861,8 @@ func NewDefinedSetFromApiStruct(a *DefinedSet) (table.DefinedSet, error) { } } +var _regexpPrefixMaskLengthRange = regexp.MustCompile(`(\d+)\.\.(\d+)`) + func (s *Server) GetDefinedSet(ctx context.Context, arg *GetDefinedSetRequest) (*GetDefinedSetResponse, error) { cd, err := s.bgpServer.GetDefinedSet(table.DefinedType(arg.Type), arg.Name) if err != nil { @@ -1487,8 +1876,7 @@ func (s *Server) GetDefinedSet(ctx context.Context, arg *GetDefinedSetRequest) ( Prefixes: func() []*Prefix { l := make([]*Prefix, 0, len(cs.PrefixList)) for _, p := range cs.PrefixList { - exp := regexp.MustCompile("(\\d+)\\.\\.(\\d+)") - elems := exp.FindStringSubmatch(p.MasklengthRange) + elems := _regexpPrefixMaskLengthRange.FindStringSubmatch(p.MasklengthRange) min, _ := strconv.ParseUint(elems[1], 10, 32) max, _ := strconv.ParseUint(elems[2], 10, 32) @@ -1581,6 +1969,8 @@ func NewAPIStatementFromTableStruct(t *table.Statement) *Statement { return toStatementApi(t.ToConfig()) } +var _regexpMedActionType = regexp.MustCompile(`([+-]?)(\d+)`) + func toStatementApi(s *config.Statement) *Statement { cs := &Conditions{} if s.Conditions.MatchPrefixSet.PrefixSet != "" { @@ -1630,6 +2020,18 @@ func toStatementApi(s *config.Statement) *Statement { if s.Conditions.BgpConditions.RouteType != "" { cs.RouteType = Conditions_RouteType(s.Conditions.BgpConditions.RouteType.ToInt()) } + if len(s.Conditions.BgpConditions.NextHopInList) > 0 { + cs.NextHopInList = s.Conditions.BgpConditions.NextHopInList + } + if s.Conditions.BgpConditions.AfiSafiInList != nil { + afiSafiIn := make([]Family, 0) + for _, afiSafiType := range s.Conditions.BgpConditions.AfiSafiInList { + if mapped, ok := bgp.AddressFamilyValueMap[string(afiSafiType)]; ok { + afiSafiIn = append(afiSafiIn, Family(mapped)) + } + } + cs.AfiSafiIn = afiSafiIn + } cs.RpkiResult = int32(s.Conditions.BgpConditions.RpkiValidationResult.ToInt()) as := &Actions{ RouteAction: func() RouteAction { @@ -1654,8 +2056,7 @@ func toStatementApi(s *config.Statement) *Statement { if len(medStr) == 0 { return nil } - re := regexp.MustCompile("([+-]?)(\\d+)") - matches := re.FindStringSubmatch(medStr) + matches := _regexpMedActionType.FindStringSubmatch(medStr) if len(matches) == 0 { return nil } @@ -1882,6 +2283,29 @@ func NewLargeCommunityConditionFromApiStruct(a *MatchSet) (*table.LargeCommunity return table.NewLargeCommunityCondition(c) } +func NewNextHopConditionFromApiStruct(a []string) (*table.NextHopCondition, error) { + if a == nil { + return nil, nil + } + + return table.NewNextHopCondition(a) +} + +func NewAfiSafiInConditionFromApiStruct(a []Family) (*table.AfiSafiInCondition, error) { + if a == nil { + return nil, nil + } + afiSafiTypes := make([]config.AfiSafiType, 0, len(a)) + for _, aType := range a { + if configType, ok := bgp.AddressFamilyNameMap[bgp.RouteFamily(aType)]; ok { + afiSafiTypes = append(afiSafiTypes, config.AfiSafiType(configType)) + } else { + return nil, fmt.Errorf("unknown afi-safi-in type value: %d", aType) + } + } + return table.NewAfiSafiInCondition(afiSafiTypes) +} + func NewRoutingActionFromApiStruct(a RouteAction) (*table.RoutingAction, error) { if a == RouteAction_NONE { return nil, nil @@ -2011,6 +2435,12 @@ func NewStatementFromApiStruct(a *Statement) (*table.Statement, error) { func() (table.Condition, error) { return NewLargeCommunityConditionFromApiStruct(a.Conditions.LargeCommunitySet) }, + func() (table.Condition, error) { + return NewNextHopConditionFromApiStruct(a.Conditions.NextHopInList) + }, + func() (table.Condition, error) { + return NewAfiSafiInConditionFromApiStruct(a.Conditions.AfiSafiIn) + }, } cs = make([]table.Condition, 0, len(cfs)) for _, f := range cfs { @@ -2132,8 +2562,6 @@ func NewAPIPolicyAssignmentFromTableStruct(t *table.PolicyAssignment) *PolicyAss return &PolicyAssignment{ Type: func() PolicyType { switch t.Type { - case table.POLICY_DIRECTION_IN: - return PolicyType_IN case table.POLICY_DIRECTION_IMPORT: return PolicyType_IMPORT case table.POLICY_DIRECTION_EXPORT: @@ -2168,6 +2596,28 @@ func NewAPIPolicyAssignmentFromTableStruct(t *table.PolicyAssignment) *PolicyAss } } +func NewConfigPolicyFromApiStruct(a *Policy) (*config.PolicyDefinition, error) { + if a.Name == "" { + return nil, fmt.Errorf("empty policy name") + } + stmts := make([]config.Statement, 0, len(a.Statements)) + for idx, x := range a.Statements { + if x.Name == "" { + x.Name = fmt.Sprintf("%s_stmt%d", a.Name, idx) + } + y, err := NewStatementFromApiStruct(x) + if err != nil { + return nil, err + } + stmt := y.ToConfig() + stmts = append(stmts, *stmt) + } + return &config.PolicyDefinition{ + Name: a.Name, + Statements: stmts, + }, nil +} + func NewPolicyFromApiStruct(a *Policy) (*table.Policy, error) { if a.Name == "" { return nil, fmt.Errorf("empty policy name") @@ -2261,8 +2711,6 @@ func toPolicyAssignmentName(a *PolicyAssignment) (string, table.PolicyDirection, } case Resource_LOCAL: switch a.Type { - case PolicyType_IN: - return a.Name, table.POLICY_DIRECTION_IN, nil case PolicyType_IMPORT: return a.Name, table.POLICY_DIRECTION_IMPORT, nil case PolicyType_EXPORT: @@ -2370,6 +2818,134 @@ func (s *Server) GetServer(ctx context.Context, arg *GetServerRequest) (*GetServ }, nil } +func NewGlobalFromAPIStruct(a *Global) *config.Global { + families := make([]config.AfiSafi, 0, len(a.Families)) + for _, f := range a.Families { + name := config.IntToAfiSafiTypeMap[int(f)] + rf, _ := bgp.GetRouteFamily(string(name)) + families = append(families, config.AfiSafi{ + Config: config.AfiSafiConfig{ + AfiSafiName: name, + Enabled: true, + }, + State: config.AfiSafiState{ + AfiSafiName: name, + Enabled: true, + Family: rf, + }, + }) + } + + applyPolicy := &config.ApplyPolicy{} + ReadApplyPolicyFromAPIStruct(applyPolicy, a.ApplyPolicy) + + global := &config.Global{ + Config: config.GlobalConfig{ + As: a.As, + RouterId: a.RouterId, + Port: a.ListenPort, + LocalAddressList: a.ListenAddresses, + }, + ApplyPolicy: *applyPolicy, + AfiSafis: families, + UseMultiplePaths: config.UseMultiplePaths{ + Config: config.UseMultiplePathsConfig{ + Enabled: a.UseMultiplePaths, + }, + }, + } + if a.RouteSelectionOptions != nil { + global.RouteSelectionOptions = config.RouteSelectionOptions{ + Config: config.RouteSelectionOptionsConfig{ + AlwaysCompareMed: a.RouteSelectionOptions.AlwaysCompareMed, + IgnoreAsPathLength: a.RouteSelectionOptions.IgnoreAsPathLength, + ExternalCompareRouterId: a.RouteSelectionOptions.ExternalCompareRouterId, + AdvertiseInactiveRoutes: a.RouteSelectionOptions.AdvertiseInactiveRoutes, + EnableAigp: a.RouteSelectionOptions.EnableAigp, + IgnoreNextHopIgpMetric: a.RouteSelectionOptions.IgnoreNextHopIgpMetric, + DisableBestPathSelection: a.RouteSelectionOptions.DisableBestPathSelection, + }, + } + } + if a.DefaultRouteDistance != nil { + global.DefaultRouteDistance = config.DefaultRouteDistance{ + Config: config.DefaultRouteDistanceConfig{ + ExternalRouteDistance: uint8(a.DefaultRouteDistance.ExternalRouteDistance), + InternalRouteDistance: uint8(a.DefaultRouteDistance.InternalRouteDistance), + }, + } + } + if a.Confederation != nil { + global.Confederation = config.Confederation{ + Config: config.ConfederationConfig{ + Enabled: a.Confederation.Enabled, + Identifier: a.Confederation.Identifier, + MemberAsList: a.Confederation.MemberAsList, + }, + } + } + if a.GracefulRestart != nil { + global.GracefulRestart = config.GracefulRestart{ + Config: config.GracefulRestartConfig{ + Enabled: a.GracefulRestart.Enabled, + RestartTime: uint16(a.GracefulRestart.RestartTime), + StaleRoutesTime: float64(a.GracefulRestart.StaleRoutesTime), + HelperOnly: a.GracefulRestart.HelperOnly, + DeferralTime: uint16(a.GracefulRestart.DeferralTime), + NotificationEnabled: a.GracefulRestart.NotificationEnabled, + LongLivedEnabled: a.GracefulRestart.LonglivedEnabled, + }, + } + } + return global +} + +func NewGlobalFromConfigStruct(c *config.Global) *Global { + families := make([]uint32, 0, len(c.AfiSafis)) + for _, f := range c.AfiSafis { + families = append(families, uint32(config.AfiSafiTypeToIntMap[f.Config.AfiSafiName])) + } + + applyPolicy := NewApplyPolicyFromConfigStruct(&c.ApplyPolicy) + + return &Global{ + As: c.Config.As, + RouterId: c.Config.RouterId, + ListenPort: c.Config.Port, + ListenAddresses: c.Config.LocalAddressList, + Families: families, + UseMultiplePaths: c.UseMultiplePaths.Config.Enabled, + RouteSelectionOptions: &RouteSelectionOptionsConfig{ + AlwaysCompareMed: c.RouteSelectionOptions.Config.AlwaysCompareMed, + IgnoreAsPathLength: c.RouteSelectionOptions.Config.IgnoreAsPathLength, + ExternalCompareRouterId: c.RouteSelectionOptions.Config.ExternalCompareRouterId, + AdvertiseInactiveRoutes: c.RouteSelectionOptions.Config.AdvertiseInactiveRoutes, + EnableAigp: c.RouteSelectionOptions.Config.EnableAigp, + IgnoreNextHopIgpMetric: c.RouteSelectionOptions.Config.IgnoreNextHopIgpMetric, + DisableBestPathSelection: c.RouteSelectionOptions.Config.DisableBestPathSelection, + }, + DefaultRouteDistance: &DefaultRouteDistance{ + ExternalRouteDistance: uint32(c.DefaultRouteDistance.Config.ExternalRouteDistance), + InternalRouteDistance: uint32(c.DefaultRouteDistance.Config.InternalRouteDistance), + }, + Confederation: &Confederation{ + Enabled: c.Confederation.Config.Enabled, + Identifier: c.Confederation.Config.Identifier, + MemberAsList: c.Confederation.Config.MemberAsList, + }, + GracefulRestart: &GracefulRestart{ + Enabled: c.GracefulRestart.Config.Enabled, + RestartTime: uint32(c.GracefulRestart.Config.RestartTime), + StaleRoutesTime: uint32(c.GracefulRestart.Config.StaleRoutesTime), + HelperOnly: c.GracefulRestart.Config.HelperOnly, + DeferralTime: uint32(c.GracefulRestart.Config.DeferralTime), + NotificationEnabled: c.GracefulRestart.Config.NotificationEnabled, + LonglivedEnabled: c.GracefulRestart.Config.LongLivedEnabled, + }, + ApplyPolicy: applyPolicy, + } +} + func (s *Server) StartServer(ctx context.Context, arg *StartServerRequest) (*StartServerResponse, error) { if arg == nil || arg.Global == nil { return nil, fmt.Errorf("invalid request") @@ -2378,36 +2954,10 @@ func (s *Server) StartServer(ctx context.Context, arg *StartServerRequest) (*Sta if net.ParseIP(g.RouterId) == nil { return nil, fmt.Errorf("invalid router-id format: %s", g.RouterId) } - families := make([]config.AfiSafi, 0, len(g.Families)) - for _, f := range g.Families { - name := config.AfiSafiType(bgp.RouteFamily(f).String()) - families = append(families, config.AfiSafi{ - Config: config.AfiSafiConfig{ - AfiSafiName: name, - Enabled: true, - }, - State: config.AfiSafiState{ - AfiSafiName: name, - }, - }) - } - b := &config.BgpConfigSet{ - Global: config.Global{ - Config: config.GlobalConfig{ - As: g.As, - RouterId: g.RouterId, - Port: g.ListenPort, - LocalAddressList: g.ListenAddresses, - }, - AfiSafis: families, - UseMultiplePaths: config.UseMultiplePaths{ - Config: config.UseMultiplePathsConfig{ - Enabled: g.UseMultiplePaths, - }, - }, - }, - } - return &StartServerResponse{}, s.bgpServer.Start(&b.Global) + + global := NewGlobalFromAPIStruct(arg.Global) + + return &StartServerResponse{}, s.bgpServer.Start(global) } func (s *Server) StopServer(ctx context.Context, arg *StopServerRequest) (*StopServerResponse, error) { @@ -2448,5 +2998,17 @@ func (s *Server) GetRibInfo(ctx context.Context, arg *GetRibInfoRequest) (*GetRi NumAccepted: uint64(info.NumAccepted), }, }, nil - +} + +func (s *Server) AddCollector(ctx context.Context, arg *AddCollectorRequest) (*AddCollectorResponse, error) { + return &AddCollectorResponse{}, s.bgpServer.AddCollector(&config.CollectorConfig{ + Url: arg.Url, + DbName: arg.DbName, + TableDumpInterval: arg.TableDumpInterval, + }) +} + +func (s *Server) Shutdown(ctx context.Context, arg *ShutdownRequest) (*ShutdownResponse, error) { + s.bgpServer.Shutdown() + return &ShutdownResponse{}, nil } diff --git a/vendor/github.com/osrg/gobgp/api/util.go b/vendor/github.com/osrg/gobgp/api/util.go index 53a94ed3..90aa5384 100644 --- a/vendor/github.com/osrg/gobgp/api/util.go +++ b/vendor/github.com/osrg/gobgp/api/util.go @@ -61,7 +61,7 @@ func (d *Destination) ToNativeDestination(option ...ToNativeOption) (*table.Dest if len(d.Paths) == 0 { return nil, fmt.Errorf("no path in destination") } - nlri, err := getNLRI(bgp.RouteFamily(d.Paths[0].Family), d.Paths[0].Nlri) + nlri, err := d.Paths[0].GetNativeNlri() if err != nil { return nil, err } @@ -86,7 +86,30 @@ func (d *Destination) ToNativeDestination(option ...ToNativeOption) (*table.Dest } func (p *Path) GetNativeNlri() (bgp.AddrPrefixInterface, error) { - return getNLRI(bgp.RouteFamily(p.Family), p.Nlri) + if len(p.Nlri) > 0 { + return getNLRI(bgp.RouteFamily(p.Family), p.Nlri) + } + return UnmarshalNLRI(bgp.RouteFamily(p.Family), p.AnyNlri) +} + +func (p *Path) GetNativePathAttributes() ([]bgp.PathAttributeInterface, error) { + pattrsLen := len(p.Pattrs) + if pattrsLen > 0 { + pattrs := make([]bgp.PathAttributeInterface, 0, pattrsLen) + for _, attr := range p.Pattrs { + a, err := bgp.GetPathAttribute(attr) + if err != nil { + return nil, err + } + err = a.DecodeFromBytes(attr) + if err != nil { + return nil, err + } + pattrs = append(pattrs, a) + } + return pattrs, nil + } + return UnmarshalPathAttributes(p.AnyPattrs) } func (p *Path) ToNativePath(option ...ToNativeOption) (*table.Path, error) { @@ -105,60 +128,54 @@ func (p *Path) ToNativePath(option ...ToNativeOption) (*table.Path, error) { } if nlri == nil { var err error - nlri, err = getNLRI(bgp.RouteFamily(p.Family), p.Nlri) + nlri, err = p.GetNativeNlri() if err != nil { return nil, err } } - pattr := make([]bgp.PathAttributeInterface, 0, len(p.Pattrs)) - for _, attr := range p.Pattrs { - p, err := bgp.GetPathAttribute(attr) - if err != nil { - return nil, err - } - err = p.DecodeFromBytes(attr) - if err != nil { - return nil, err - } - pattr = append(pattr, p) + pattr, err := p.GetNativePathAttributes() + if err != nil { + return nil, err } t := time.Unix(p.Age, 0) nlri.SetPathIdentifier(p.Identifier) nlri.SetPathLocalIdentifier(p.LocalIdentifier) path := table.NewPath(info, nlri, p.IsWithdraw, pattr, t, false) + + // p.ValidationDetail.* are already validated + matched, _ := NewROAListFromApiStructList(p.ValidationDetail.Matched) + unmatchedAs, _ := NewROAListFromApiStructList(p.ValidationDetail.UnmatchedAs) + unmatchedLength, _ := NewROAListFromApiStructList(p.ValidationDetail.UnmatchedLength) + path.SetValidation(&table.Validation{ Status: config.IntToRpkiValidationResultTypeMap[int(p.Validation)], Reason: table.IntToRpkiValidationReasonTypeMap[int(p.ValidationDetail.Reason)], - Matched: NewROAListFromApiStructList(p.ValidationDetail.Matched), - UnmatchedAs: NewROAListFromApiStructList(p.ValidationDetail.UnmatchedAs), - UnmatchedLength: NewROAListFromApiStructList(p.ValidationDetail.UnmatchedLength), + Matched: matched, + UnmatchedAs: unmatchedAs, + UnmatchedLength: unmatchedLength, }) path.MarkStale(p.Stale) - path.SetUUID(p.Uuid) - if p.Filtered { - path.Filter("", table.POLICY_DIRECTION_IN) - } path.IsNexthopInvalid = p.IsNexthopInvalid return path, nil } -func NewROAListFromApiStructList(l []*Roa) []*table.ROA { +func NewROAListFromApiStructList(l []*Roa) ([]*table.ROA, error) { roas := make([]*table.ROA, 0, len(l)) for _, r := range l { ip := net.ParseIP(r.Prefix) - rf := func(prefix string) bgp.RouteFamily { - a, _, _ := net.ParseCIDR(prefix) - if a.To4() != nil { - return bgp.RF_IPv4_UC - } else { - return bgp.RF_IPv6_UC + family := bgp.RF_IPv4_UC + if ip == nil { + return nil, fmt.Errorf("invalid prefix %s", r.Prefix) + } else { + if ip.To4() == nil { + family = bgp.RF_IPv6_UC } - }(r.Prefix) - afi, _ := bgp.RouteFamilyToAfiSafi(rf) + } + afi, _ := bgp.RouteFamilyToAfiSafi(family) roa := table.NewROA(int(afi), []byte(ip), uint8(r.Prefixlen), uint8(r.Maxlen), r.As, net.JoinHostPort(r.Conf.Address, r.Conf.RemotePort)) roas = append(roas, roa) } - return roas + return roas, nil } func extractFamilyFromConfigAfiSafi(c *config.AfiSafi) uint32 { diff --git a/vendor/github.com/osrg/gobgp/client/client.go b/vendor/github.com/osrg/gobgp/client/client.go index 4cd22526..05877198 100644 --- a/vendor/github.com/osrg/gobgp/client/client.go +++ b/vendor/github.com/osrg/gobgp/client/client.go @@ -198,8 +198,11 @@ func (cli *Client) DeleteNeighbor(c *config.Neighbor) error { return err } -//func (cli *Client) UpdateNeighbor(c *config.Neighbor) (bool, error) { -//} +func (cli *Client) UpdateNeighbor(c *config.Neighbor, doSoftResetIn bool) (bool, error) { + peer := api.NewPeerFromConfigStruct(c) + response, err := cli.cli.UpdateNeighbor(context.Background(), &api.UpdateNeighborRequest{Peer: peer, DoSoftResetIn: doSoftResetIn}) + return response.NeedsSoftResetIn, err +} func (cli *Client) ShutdownNeighbor(addr, communication string) error { _, err := cli.cli.ShutdownNeighbor(context.Background(), &api.ShutdownNeighborRequest{Address: addr, Communication: communication}) @@ -354,7 +357,7 @@ type AddPathByStreamClient struct { func (c *AddPathByStreamClient) Send(paths ...*table.Path) error { ps := make([]*api.Path, 0, len(paths)) for _, p := range paths { - ps = append(ps, api.ToPathApi(p)) + ps = append(ps, api.ToPathApiInBin(p, nil)) } return c.stream.Send(&api.InjectMrtRequest{ Resource: api.Resource_GLOBAL, @@ -385,7 +388,7 @@ func (cli *Client) addPath(vrfID string, pathList []*table.Path) ([]byte, error) r, err := cli.cli.AddPath(context.Background(), &api.AddPathRequest{ Resource: resource, VrfId: vrfID, - Path: api.ToPathApi(path), + Path: api.ToPathApi(path, nil), }) if err != nil { return nil, err @@ -416,21 +419,10 @@ func (cli *Client) deletePath(uuid []byte, f bgp.RouteFamily, vrfID string, path switch { case len(pathList) != 0: for _, path := range pathList { - nlri := path.GetNlri() - n, err := nlri.Serialize() - if err != nil { - return err - } - p := &api.Path{ - Nlri: n, - Family: uint32(path.GetRouteFamily()), - Identifier: nlri.PathIdentifier(), - LocalIdentifier: nlri.PathLocalIdentifier(), - } reqs = append(reqs, &api.DeletePathRequest{ Resource: resource, VrfId: vrfID, - Path: p, + Path: api.ToPathApi(path, nil), }) } default: @@ -469,83 +461,25 @@ func (cli *Client) DeletePathByFamily(family bgp.RouteFamily) error { return cli.deletePath(nil, family, "", nil) } -func (cli *Client) GetVRF() ([]*table.Vrf, error) { +func (cli *Client) GetVRF() ([]*api.Vrf, error) { ret, err := cli.cli.GetVrf(context.Background(), &api.GetVrfRequest{}) if err != nil { return nil, err } - var vrfs []*table.Vrf - - f := func(bufs [][]byte) ([]bgp.ExtendedCommunityInterface, error) { - ret := make([]bgp.ExtendedCommunityInterface, 0, len(bufs)) - for _, rt := range bufs { - r, err := bgp.ParseExtended(rt) - if err != nil { - return nil, err - } - ret = append(ret, r) - } - return ret, nil - } - - for _, vrf := range ret.Vrfs { - importRT, err := f(vrf.ImportRt) - if err != nil { - return nil, err - } - exportRT, err := f(vrf.ExportRt) - if err != nil { - return nil, err - } - vrfs = append(vrfs, &table.Vrf{ - Name: vrf.Name, - Id: vrf.Id, - Rd: bgp.GetRouteDistinguisher(vrf.Rd), - ImportRt: importRT, - ExportRt: exportRT, - }) - } - - return vrfs, nil + return ret.Vrfs, nil } func (cli *Client) AddVRF(name string, id int, rd bgp.RouteDistinguisherInterface, im, ex []bgp.ExtendedCommunityInterface) error { - buf, err := rd.Serialize() - if err != nil { - return err - } - - f := func(comms []bgp.ExtendedCommunityInterface) ([][]byte, error) { - var bufs [][]byte - for _, c := range comms { - buf, err := c.Serialize() - if err != nil { - return nil, err - } - bufs = append(bufs, buf) - } - return bufs, err - } - - importRT, err := f(im) - if err != nil { - return err - } - exportRT, err := f(ex) - if err != nil { - return err - } - arg := &api.AddVrfRequest{ Vrf: &api.Vrf{ Name: name, - Rd: buf, + Rd: api.MarshalRD(rd), Id: uint32(id), - ImportRt: importRT, - ExportRt: exportRT, + ImportRt: api.MarshalRTs(im), + ExportRt: api.MarshalRTs(ex), }, } - _, err = cli.cli.AddVrf(context.Background(), arg) + _, err := cli.cli.AddVrf(context.Background(), arg) return err } @@ -718,8 +652,6 @@ func (cli *Client) ReplacePolicy(t *table.Policy, refer, preserve bool) error { func (cli *Client) getPolicyAssignment(name string, dir table.PolicyDirection) (*table.PolicyAssignment, error) { var typ api.PolicyType switch dir { - case table.POLICY_DIRECTION_IN: - typ = api.PolicyType_IN case table.POLICY_DIRECTION_IMPORT: typ = api.PolicyType_IMPORT case table.POLICY_DIRECTION_EXPORT: @@ -770,10 +702,6 @@ func (cli *Client) GetExportPolicy() (*table.PolicyAssignment, error) { return cli.getPolicyAssignment("", table.POLICY_DIRECTION_EXPORT) } -func (cli *Client) GetRouteServerInPolicy(name string) (*table.PolicyAssignment, error) { - return cli.getPolicyAssignment(name, table.POLICY_DIRECTION_IN) -} - func (cli *Client) GetRouteServerImportPolicy(name string) (*table.PolicyAssignment, error) { return cli.getPolicyAssignment(name, table.POLICY_DIRECTION_IMPORT) } @@ -867,7 +795,7 @@ func (cli *Client) GetROA(family bgp.RouteFamily) ([]*table.ROA, error) { if err != nil { return nil, err } - return api.NewROAListFromApiStructList(rsp.Roas), nil + return api.NewROAListFromApiStructList(rsp.Roas) } func (cli *Client) AddRPKIServer(address string, port, lifetime int) error { diff --git a/vendor/github.com/osrg/gobgp/config/bgp_configs.go b/vendor/github.com/osrg/gobgp/config/bgp_configs.go index 402bff40..8268769e 100644 --- a/vendor/github.com/osrg/gobgp/config/bgp_configs.go +++ b/vendor/github.com/osrg/gobgp/config/bgp_configs.go @@ -1114,7 +1114,7 @@ type ZebraState struct { // Configure url for zebra. Url string `mapstructure:"url" json:"url,omitempty"` // original -> gobgp:redistribute-route-type - RedistributeRouteTypeList []InstallProtocolType `mapstructure:"redistribute-route-type-list" json:"redistribute-route-type-list,omitempty"` + RedistributeRouteTypeList []string `mapstructure:"redistribute-route-type-list" json:"redistribute-route-type-list,omitempty"` // original -> gobgp:version // Configure version of zebra protocol. Default is 2. Supported up to 3. Version uint8 `mapstructure:"version" json:"version,omitempty"` @@ -1135,7 +1135,7 @@ type ZebraConfig struct { // Configure url for zebra. Url string `mapstructure:"url" json:"url,omitempty"` // original -> gobgp:redistribute-route-type - RedistributeRouteTypeList []InstallProtocolType `mapstructure:"redistribute-route-type-list" json:"redistribute-route-type-list,omitempty"` + RedistributeRouteTypeList []string `mapstructure:"redistribute-route-type-list" json:"redistribute-route-type-list,omitempty"` // original -> gobgp:version // Configure version of zebra protocol. Default is 2. Supported up to 3. Version uint8 `mapstructure:"version" json:"version,omitempty"` @@ -1249,6 +1249,112 @@ func (lhs *Mrt) Equal(rhs *Mrt) bool { return true } +// struct for container gobgp:state. +// Configured states of VRF. +type VrfState struct { + // original -> gobgp:name + // Unique name among all VRF instances. + Name string `mapstructure:"name" json:"name,omitempty"` + // original -> gobgp:id + // Unique identifier among all VRF instances. + Id uint32 `mapstructure:"id" json:"id,omitempty"` + // original -> gobgp:rd + // Route Distinguisher for this VRF. + Rd string `mapstructure:"rd" json:"rd,omitempty"` + // original -> gobgp:import-rt + // List of import Route Targets for this VRF. + ImportRtList []string `mapstructure:"import-rt-list" json:"import-rt-list,omitempty"` + // original -> gobgp:export-rt + // List of export Route Targets for this VRF. + ExportRtList []string `mapstructure:"export-rt-list" json:"export-rt-list,omitempty"` +} + +// struct for container gobgp:config. +// Configuration parameters for VRF. +type VrfConfig struct { + // original -> gobgp:name + // Unique name among all VRF instances. + Name string `mapstructure:"name" json:"name,omitempty"` + // original -> gobgp:id + // Unique identifier among all VRF instances. + Id uint32 `mapstructure:"id" json:"id,omitempty"` + // original -> gobgp:rd + // Route Distinguisher for this VRF. + Rd string `mapstructure:"rd" json:"rd,omitempty"` + // original -> gobgp:import-rt + // List of import Route Targets for this VRF. + ImportRtList []string `mapstructure:"import-rt-list" json:"import-rt-list,omitempty"` + // original -> gobgp:export-rt + // List of export Route Targets for this VRF. + ExportRtList []string `mapstructure:"export-rt-list" json:"export-rt-list,omitempty"` + // original -> gobgp:both-rt + // List of both import and export Route Targets for this VRF. Each + // configuration for import and export Route Targets will be preferred. + BothRtList []string `mapstructure:"both-rt-list" json:"both-rt-list,omitempty"` +} + +func (lhs *VrfConfig) Equal(rhs *VrfConfig) bool { + if lhs == nil || rhs == nil { + return false + } + if lhs.Name != rhs.Name { + return false + } + if lhs.Id != rhs.Id { + return false + } + if lhs.Rd != rhs.Rd { + return false + } + if len(lhs.ImportRtList) != len(rhs.ImportRtList) { + return false + } + for idx, l := range lhs.ImportRtList { + if l != rhs.ImportRtList[idx] { + return false + } + } + if len(lhs.ExportRtList) != len(rhs.ExportRtList) { + return false + } + for idx, l := range lhs.ExportRtList { + if l != rhs.ExportRtList[idx] { + return false + } + } + if len(lhs.BothRtList) != len(rhs.BothRtList) { + return false + } + for idx, l := range lhs.BothRtList { + if l != rhs.BothRtList[idx] { + return false + } + } + return true +} + +// struct for container gobgp:vrf. +// VRF instance configurations on the local system. +type Vrf struct { + // original -> gobgp:name + // original -> gobgp:vrf-config + // Configuration parameters for VRF. + Config VrfConfig `mapstructure:"config" json:"config,omitempty"` + // original -> gobgp:vrf-state + // Configured states of VRF. + State VrfState `mapstructure:"state" json:"state,omitempty"` +} + +func (lhs *Vrf) Equal(rhs *Vrf) bool { + if lhs == nil || rhs == nil { + return false + } + if !lhs.Config.Equal(&(rhs.Config)) { + return false + } + return true +} + // struct for container gobgp:state. // Configuration parameters relating to BMP server. type BmpServerState struct { @@ -4785,6 +4891,8 @@ type Bgp struct { RpkiServers []RpkiServer `mapstructure:"rpki-servers" json:"rpki-servers,omitempty"` // original -> gobgp:bmp-servers BmpServers []BmpServer `mapstructure:"bmp-servers" json:"bmp-servers,omitempty"` + // original -> gobgp:vrfs + Vrfs []Vrf `mapstructure:"vrfs" json:"vrfs,omitempty"` // original -> gobgp:mrt-dump MrtDump []Mrt `mapstructure:"mrt-dump" json:"mrt-dump,omitempty"` // original -> gobgp:zebra @@ -4866,6 +4974,22 @@ func (lhs *Bgp) Equal(rhs *Bgp) bool { } } } + if len(lhs.Vrfs) != len(rhs.Vrfs) { + return false + } + { + lmap := make(map[string]*Vrf) + for i, l := range lhs.Vrfs { + lmap[mapkey(i, string(l.Config.Name))] = &lhs.Vrfs[i] + } + for i, r := range rhs.Vrfs { + if l, y := lmap[mapkey(i, string(r.Config.Name))]; !y { + return false + } else if !r.Equal(l) { + return false + } + } + } if len(lhs.MrtDump) != len(rhs.MrtDump) { return false } diff --git a/vendor/github.com/osrg/gobgp/config/default.go b/vendor/github.com/osrg/gobgp/config/default.go index 5c472909..cbb11167 100644 --- a/vendor/github.com/osrg/gobgp/config/default.go +++ b/vendor/github.com/osrg/gobgp/config/default.go @@ -1,14 +1,18 @@ package config import ( + "encoding/binary" "fmt" + "math" "net" "reflect" + "strconv" + + "github.com/spf13/viper" "github.com/osrg/gobgp/packet/bgp" "github.com/osrg/gobgp/packet/bmp" "github.com/osrg/gobgp/packet/rtr" - "github.com/spf13/viper" ) const ( @@ -26,7 +30,7 @@ var configuredFields map[string]interface{} func RegisterConfiguredFields(addr string, n interface{}) { if configuredFields == nil { - configuredFields = make(map[string]interface{}, 0) + configuredFields = make(map[string]interface{}) } configuredFields[addr] = n } @@ -183,11 +187,11 @@ func setDefaultNeighborConfigValuesWithViper(v *viper.Viper, n *Neighbor, g *Glo if len(afs) > i { vv.Set("afi-safi", afs[i]) } - if rf, err := bgp.GetRouteFamily(string(n.AfiSafis[i].Config.AfiSafiName)); err != nil { + rf, err := bgp.GetRouteFamily(string(n.AfiSafis[i].Config.AfiSafiName)) + if err != nil { return err - } else { - n.AfiSafis[i].State.Family = rf } + n.AfiSafis[i].State.Family = rf n.AfiSafis[i].State.AfiSafiName = n.AfiSafis[i].Config.AfiSafiName if !vv.IsSet("afi-safi.config.enabled") { n.AfiSafis[i].Config.Enabled = true @@ -238,9 +242,18 @@ func setDefaultNeighborConfigValuesWithViper(v *viper.Viper, n *Neighbor, g *Glo if n.RouteReflector.Config.RouteReflectorClient { if n.RouteReflector.Config.RouteReflectorClusterId == "" { - n.RouteReflector.Config.RouteReflectorClusterId = RrClusterIdType(g.Config.RouterId) - } else if id := net.ParseIP(string(n.RouteReflector.Config.RouteReflectorClusterId)).To4(); id == nil { - return fmt.Errorf("route-reflector-cluster-id should be specified in IPv4 address format") + n.RouteReflector.State.RouteReflectorClusterId = RrClusterIdType(g.Config.RouterId) + } else { + id := string(n.RouteReflector.Config.RouteReflectorClusterId) + if ip := net.ParseIP(id).To4(); ip != nil { + n.RouteReflector.State.RouteReflectorClusterId = n.RouteReflector.Config.RouteReflectorClusterId + } else if num, err := strconv.ParseUint(id, 10, 32); err == nil { + ip = make(net.IP, 4) + binary.BigEndian.PutUint32(ip, uint32(num)) + n.RouteReflector.State.RouteReflectorClusterId = RrClusterIdType(ip.String()) + } else { + return fmt.Errorf("route-reflector-cluster-id should be specified as IPv4 address or 32-bit unsigned integer") + } } } @@ -250,7 +263,7 @@ func setDefaultNeighborConfigValuesWithViper(v *viper.Viper, n *Neighbor, g *Glo func SetDefaultGlobalConfigValues(g *Global) error { if len(g.AfiSafis) == 0 { g.AfiSafis = []AfiSafi{} - for k, _ := range AfiSafiTypeToIntMap { + for k := range AfiSafiTypeToIntMap { g.AfiSafis = append(g.AfiSafis, defaultAfiSafi(k, true)) } } @@ -265,6 +278,43 @@ func SetDefaultGlobalConfigValues(g *Global) error { return nil } +func setDefaultVrfConfigValues(v *Vrf) error { + if v == nil { + return fmt.Errorf("cannot set default values for nil vrf config") + } + + if v.Config.Name == "" { + return fmt.Errorf("specify vrf name") + } + + _, err := bgp.ParseRouteDistinguisher(v.Config.Rd) + if err != nil { + return fmt.Errorf("invalid rd for vrf %s: %s", v.Config.Name, v.Config.Rd) + } + + if len(v.Config.ImportRtList) == 0 { + v.Config.ImportRtList = v.Config.BothRtList + } + for _, rtString := range v.Config.ImportRtList { + _, err := bgp.ParseRouteTarget(rtString) + if err != nil { + return fmt.Errorf("invalid import rt for vrf %s: %s", v.Config.Name, rtString) + } + } + + if len(v.Config.ExportRtList) == 0 { + v.Config.ExportRtList = v.Config.BothRtList + } + for _, rtString := range v.Config.ExportRtList { + _, err := bgp.ParseRouteTarget(rtString) + if err != nil { + return fmt.Errorf("invalid export rt for vrf %s: %s", v.Config.Name, rtString) + } + } + + return nil +} + func SetDefaultConfigValues(b *BgpConfigSet) error { return setDefaultConfigValuesWithViper(nil, b) } @@ -274,7 +324,7 @@ func setDefaultPolicyConfigValuesWithViper(v *viper.Viper, p *PolicyDefinition) if err != nil { return err } - for i, _ := range p.Statements { + for i := range p.Statements { vv := viper.New() if len(stmts) > i { vv.Set("statement", stmts[i]) @@ -309,6 +359,41 @@ func setDefaultConfigValuesWithViper(v *viper.Viper, b *BgpConfigSet) error { b.BmpServers[idx] = server } + vrfNames := make(map[string]struct{}) + vrfIDs := make(map[uint32]struct{}) + for idx, vrf := range b.Vrfs { + if err := setDefaultVrfConfigValues(&vrf); err != nil { + return err + } + + if _, ok := vrfNames[vrf.Config.Name]; ok { + return fmt.Errorf("duplicated vrf name: %s", vrf.Config.Name) + } + vrfNames[vrf.Config.Name] = struct{}{} + + if vrf.Config.Id != 0 { + if _, ok := vrfIDs[vrf.Config.Id]; ok { + return fmt.Errorf("duplicated vrf id: %d", vrf.Config.Id) + } + vrfIDs[vrf.Config.Id] = struct{}{} + } + + b.Vrfs[idx] = vrf + } + // Auto assign VRF identifier + for idx, vrf := range b.Vrfs { + if vrf.Config.Id == 0 { + for id := uint32(1); id < math.MaxUint32; id++ { + if _, ok := vrfIDs[id]; !ok { + vrf.Config.Id = id + vrfIDs[id] = struct{}{} + break + } + } + } + b.Vrfs[idx] = vrf + } + if b.Zebra.Config.Url == "" { b.Zebra.Config.Url = "unix:/var/run/quagga/zserv.api" } diff --git a/vendor/github.com/osrg/gobgp/config/default_linux.go b/vendor/github.com/osrg/gobgp/config/default_linux.go index 6bee2317..8cfcc501 100644 --- a/vendor/github.com/osrg/gobgp/config/default_linux.go +++ b/vendor/github.com/osrg/gobgp/config/default_linux.go @@ -18,8 +18,9 @@ package config import ( "fmt" - "github.com/vishvananda/netlink" "net" + + "github.com/vishvananda/netlink" ) func GetIPv6LinkLocalNeighborAddress(ifname string) (string, error) { @@ -40,7 +41,7 @@ func GetIPv6LinkLocalNeighborAddress(ifname string) (string, error) { } if neigh.State&netlink.NUD_FAILED == 0 && neigh.IP.IsLinkLocalUnicast() && !local { addr = neigh.IP - cnt += 1 + cnt++ } } @@ -52,3 +53,20 @@ func GetIPv6LinkLocalNeighborAddress(ifname string) (string, error) { return fmt.Sprintf("%s%%%s", addr, ifname), nil } + +func isLocalLinkLocalAddress(ifindex int, addr net.IP) (bool, error) { + ifi, err := net.InterfaceByIndex(ifindex) + if err != nil { + return false, err + } + addrs, err := ifi.Addrs() + if err != nil { + return false, err + } + for _, a := range addrs { + if ip, _, _ := net.ParseCIDR(a.String()); addr.Equal(ip) { + return true, nil + } + } + return false, nil +} diff --git a/vendor/github.com/osrg/gobgp/config/serve.go b/vendor/github.com/osrg/gobgp/config/serve.go index 45c70ea9..6b09af6e 100644 --- a/vendor/github.com/osrg/gobgp/config/serve.go +++ b/vendor/github.com/osrg/gobgp/config/serve.go @@ -1,11 +1,12 @@ package config import ( - log "github.com/sirupsen/logrus" - "github.com/spf13/viper" "os" "os/signal" "syscall" + + log "github.com/sirupsen/logrus" + "github.com/spf13/viper" ) type BgpConfigSet struct { @@ -14,6 +15,7 @@ type BgpConfigSet struct { PeerGroups []PeerGroup `mapstructure:"peer-groups"` RpkiServers []RpkiServer `mapstructure:"rpki-servers"` BmpServers []BmpServer `mapstructure:"bmp-servers"` + Vrfs []Vrf `mapstructure:"vrfs"` MrtDump []Mrt `mapstructure:"mrt-dump"` Zebra Zebra `mapstructure:"zebra"` Collector Collector `mapstructure:"collector"` @@ -66,12 +68,10 @@ func ReadConfigfileServe(path, format string, configCh chan *BgpConfigSet) { }).Warningf("Can't read config file %s", path) } NEXT: - select { - case <-sigCh: - log.WithFields(log.Fields{ - "Topic": "Config", - }).Info("Reload the config file") - } + <-sigCh + log.WithFields(log.Fields{ + "Topic": "Config", + }).Info("Reload the config file") } } @@ -145,9 +145,8 @@ func CheckPolicyDifference(currentPolicy *RoutingPolicy, newPolicy *RoutingPolic "Topic": "Config", }).Debugf("New policy:%s", newPolicy) - var result bool = false + var result bool if currentPolicy == nil && newPolicy == nil { - result = false } else { if currentPolicy != nil && newPolicy != nil { diff --git a/vendor/github.com/osrg/gobgp/config/util.go b/vendor/github.com/osrg/gobgp/config/util.go index aa393f14..e857b98b 100644 --- a/vendor/github.com/osrg/gobgp/config/util.go +++ b/vendor/github.com/osrg/gobgp/config/util.go @@ -81,23 +81,6 @@ func getIPv6LinkLocalAddress(ifname string) (string, error) { return "", fmt.Errorf("no ipv6 link local address for %s", ifname) } -func isLocalLinkLocalAddress(ifindex int, addr net.IP) (bool, error) { - ifi, err := net.InterfaceByIndex(ifindex) - if err != nil { - return false, err - } - addrs, err := ifi.Addrs() - if err != nil { - return false, err - } - for _, a := range addrs { - if ip, _, _ := net.ParseCIDR(a.String()); addr.Equal(ip) { - return true, nil - } - } - return false, nil -} - func (b *BgpConfigSet) getPeerGroup(n string) (*PeerGroup, error) { if n == "" { return nil, nil @@ -216,7 +199,7 @@ func existPeerGroup(n string, b []PeerGroup) int { return -1 } -func CheckAfiSafisChange(x, y []AfiSafi) bool { +func isAfiSafiChanged(x, y []AfiSafi) bool { if len(x) != len(y) { return true } @@ -232,6 +215,17 @@ func CheckAfiSafisChange(x, y []AfiSafi) bool { return false } +func (n *Neighbor) NeedsResendOpenMessage(new *Neighbor) bool { + return !n.Config.Equal(&new.Config) || + !n.Transport.Config.Equal(&new.Transport.Config) || + !n.AddPaths.Config.Equal(&new.AddPaths.Config) || + !n.GracefulRestart.Config.Equal(&new.GracefulRestart.Config) || + isAfiSafiChanged(n.AfiSafis, new.AfiSafis) +} + +// TODO: these regexp are duplicated in api +var _regexpPrefixMaskLengthRange = regexp.MustCompile(`(\d+)\.\.(\d+)`) + func ParseMaskLength(prefix, mask string) (int, int, error) { _, ipNet, err := net.ParseCIDR(prefix) if err != nil { @@ -241,8 +235,7 @@ func ParseMaskLength(prefix, mask string) (int, int, error) { l, _ := ipNet.Mask.Size() return l, l, nil } - exp := regexp.MustCompile("(\\d+)\\.\\.(\\d+)") - elems := exp.FindStringSubmatch(mask) + elems := _regexpPrefixMaskLengthRange.FindStringSubmatch(mask) if len(elems) != 3 { return 0, 0, fmt.Errorf("invalid mask length range: %s", mask) } diff --git a/vendor/github.com/osrg/gobgp/gobgp/cmd/common.go b/vendor/github.com/osrg/gobgp/gobgp/cmd/common.go index 99229008..7add79a1 100644 --- a/vendor/github.com/osrg/gobgp/gobgp/cmd/common.go +++ b/vendor/github.com/osrg/gobgp/gobgp/cmd/common.go @@ -29,10 +29,10 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/credentials" + api "github.com/osrg/gobgp/api" cli "github.com/osrg/gobgp/client" "github.com/osrg/gobgp/config" "github.com/osrg/gobgp/packet/bgp" - "github.com/osrg/gobgp/table" ) const ( @@ -97,23 +97,6 @@ var neighborsOpts struct { Transport string `short:"t" long:"transport" description:"specifying a transport protocol"` } -var conditionOpts struct { - Prefix string `long:"prefix" description:"specifying a prefix set name of policy"` - Neighbor string `long:"neighbor" description:"specifying a neighbor set name of policy"` - AsPath string `long:"aspath" description:"specifying an as set name of policy"` - Community string `long:"community" description:"specifying a community set name of policy"` - ExtCommunity string `long:"extcommunity" description:"specifying a extended community set name of policy"` - AsPathLength string `long:"aspath-len" description:"specifying an as path length of policy (,)"` -} - -var actionOpts struct { - RouteAction string `long:"route-action" description:"specifying a route action of policy (accept | reject)"` - CommunityAction string `long:"community" description:"specifying a community action of policy"` - MedAction string `long:"med" description:"specifying a med action of policy"` - AsPathPrependAction string `long:"as-prepend" description:"specifying a as-prepend action of policy"` - NexthopAction string `long:"next-hop" description:"specifying a next-hop action of policy"` -} - var mrtOpts struct { OutputDir string FileFormat string @@ -142,9 +125,8 @@ func formatTimedelta(d int64) string { if days == 0 { return fmt.Sprintf("%02d:%02d:%02d", hours, mins, secs) - } else { - return fmt.Sprintf("%dd ", days) + fmt.Sprintf("%02d:%02d:%02d", hours, mins, secs) } + return fmt.Sprintf("%dd ", days) + fmt.Sprintf("%02d:%02d:%02d", hours, mins, secs) } func cidr2prefix(cidr string) string { @@ -217,10 +199,7 @@ func (n neighbors) Less(i, j int) bool { p1Isv4 := !strings.Contains(p1, ":") p2Isv4 := !strings.Contains(p2, ":") if p1Isv4 != p2Isv4 { - if p1Isv4 { - return true - } - return false + return p1Isv4 } addrlen := 128 if p1Isv4 { @@ -245,7 +224,7 @@ func (c capabilities) Less(i, j int) bool { return c[i].Code() < c[j].Code() } -type vrfs []*table.Vrf +type vrfs []*api.Vrf func (v vrfs) Len() int { return len(v) @@ -281,7 +260,7 @@ func newClient() *cli.Client { target := net.JoinHostPort(globalOpts.Host, strconv.Itoa(globalOpts.Port)) client, err := cli.New(target, grpcOpts...) if err != nil { - exitWithError(err) + exitWithError(fmt.Errorf("failed to connect to %s over gRPC: %s", target, err)) } return client } diff --git a/vendor/github.com/osrg/gobgp/gobgp/cmd/global.go b/vendor/github.com/osrg/gobgp/gobgp/cmd/global.go index c9be51bc..91c71ff5 100644 --- a/vendor/github.com/osrg/gobgp/gobgp/cmd/global.go +++ b/vendor/github.com/osrg/gobgp/gobgp/cmd/global.go @@ -465,22 +465,23 @@ func ParseEvpnEthernetAutoDiscoveryArgs(args []string) (bgp.AddrPrefixInterface, func ParseEvpnMacAdvArgs(args []string) (bgp.AddrPrefixInterface, []string, error) { // Format: - // [esi ] etag label