David K. Bainbridge | 215e024 | 2017-09-05 23:18:24 -0700 | [diff] [blame] | 1 | // Copyright 2013 The Go Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style |
| 3 | // license that can be found in the LICENSE file. |
| 4 | |
| 5 | // +build ignore |
| 6 | |
| 7 | //go:generate go run gen.go |
| 8 | |
| 9 | // This program generates internet protocol constants and tables by |
| 10 | // reading IANA protocol registries. |
| 11 | package main |
| 12 | |
| 13 | import ( |
| 14 | "bytes" |
| 15 | "encoding/xml" |
| 16 | "fmt" |
| 17 | "go/format" |
| 18 | "io" |
| 19 | "io/ioutil" |
| 20 | "net/http" |
| 21 | "os" |
| 22 | "strconv" |
| 23 | "strings" |
| 24 | ) |
| 25 | |
| 26 | var registries = []struct { |
| 27 | url string |
| 28 | parse func(io.Writer, io.Reader) error |
| 29 | }{ |
| 30 | { |
| 31 | "http://www.iana.org/assignments/dscp-registry/dscp-registry.xml", |
| 32 | parseDSCPRegistry, |
| 33 | }, |
| 34 | { |
| 35 | "http://www.iana.org/assignments/ipv4-tos-byte/ipv4-tos-byte.xml", |
| 36 | parseTOSTCByte, |
| 37 | }, |
| 38 | { |
| 39 | "http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xml", |
| 40 | parseProtocolNumbers, |
| 41 | }, |
| 42 | } |
| 43 | |
| 44 | func main() { |
| 45 | var bb bytes.Buffer |
| 46 | fmt.Fprintf(&bb, "// go generate gen.go\n") |
| 47 | fmt.Fprintf(&bb, "// GENERATED BY THE COMMAND ABOVE; DO NOT EDIT\n\n") |
| 48 | fmt.Fprintf(&bb, "// Package iana provides protocol number resources managed by the Internet Assigned Numbers Authority (IANA).\n") |
| 49 | fmt.Fprintf(&bb, `package iana // import "golang.org/x/net/internal/iana"`+"\n\n") |
| 50 | for _, r := range registries { |
| 51 | resp, err := http.Get(r.url) |
| 52 | if err != nil { |
| 53 | fmt.Fprintln(os.Stderr, err) |
| 54 | os.Exit(1) |
| 55 | } |
| 56 | defer resp.Body.Close() |
| 57 | if resp.StatusCode != http.StatusOK { |
| 58 | fmt.Fprintf(os.Stderr, "got HTTP status code %v for %v\n", resp.StatusCode, r.url) |
| 59 | os.Exit(1) |
| 60 | } |
| 61 | if err := r.parse(&bb, resp.Body); err != nil { |
| 62 | fmt.Fprintln(os.Stderr, err) |
| 63 | os.Exit(1) |
| 64 | } |
| 65 | fmt.Fprintf(&bb, "\n") |
| 66 | } |
| 67 | b, err := format.Source(bb.Bytes()) |
| 68 | if err != nil { |
| 69 | fmt.Fprintln(os.Stderr, err) |
| 70 | os.Exit(1) |
| 71 | } |
| 72 | if err := ioutil.WriteFile("const.go", b, 0644); err != nil { |
| 73 | fmt.Fprintln(os.Stderr, err) |
| 74 | os.Exit(1) |
| 75 | } |
| 76 | } |
| 77 | |
| 78 | func parseDSCPRegistry(w io.Writer, r io.Reader) error { |
| 79 | dec := xml.NewDecoder(r) |
| 80 | var dr dscpRegistry |
| 81 | if err := dec.Decode(&dr); err != nil { |
| 82 | return err |
| 83 | } |
| 84 | drs := dr.escape() |
| 85 | fmt.Fprintf(w, "// %s, Updated: %s\n", dr.Title, dr.Updated) |
| 86 | fmt.Fprintf(w, "const (\n") |
| 87 | for _, dr := range drs { |
| 88 | fmt.Fprintf(w, "DiffServ%s = %#x", dr.Name, dr.Value) |
| 89 | fmt.Fprintf(w, "// %s\n", dr.OrigName) |
| 90 | } |
| 91 | fmt.Fprintf(w, ")\n") |
| 92 | return nil |
| 93 | } |
| 94 | |
| 95 | type dscpRegistry struct { |
| 96 | XMLName xml.Name `xml:"registry"` |
| 97 | Title string `xml:"title"` |
| 98 | Updated string `xml:"updated"` |
| 99 | Note string `xml:"note"` |
| 100 | RegTitle string `xml:"registry>title"` |
| 101 | PoolRecords []struct { |
| 102 | Name string `xml:"name"` |
| 103 | Space string `xml:"space"` |
| 104 | } `xml:"registry>record"` |
| 105 | Records []struct { |
| 106 | Name string `xml:"name"` |
| 107 | Space string `xml:"space"` |
| 108 | } `xml:"registry>registry>record"` |
| 109 | } |
| 110 | |
| 111 | type canonDSCPRecord struct { |
| 112 | OrigName string |
| 113 | Name string |
| 114 | Value int |
| 115 | } |
| 116 | |
| 117 | func (drr *dscpRegistry) escape() []canonDSCPRecord { |
| 118 | drs := make([]canonDSCPRecord, len(drr.Records)) |
| 119 | sr := strings.NewReplacer( |
| 120 | "+", "", |
| 121 | "-", "", |
| 122 | "/", "", |
| 123 | ".", "", |
| 124 | " ", "", |
| 125 | ) |
| 126 | for i, dr := range drr.Records { |
| 127 | s := strings.TrimSpace(dr.Name) |
| 128 | drs[i].OrigName = s |
| 129 | drs[i].Name = sr.Replace(s) |
| 130 | n, err := strconv.ParseUint(dr.Space, 2, 8) |
| 131 | if err != nil { |
| 132 | continue |
| 133 | } |
| 134 | drs[i].Value = int(n) << 2 |
| 135 | } |
| 136 | return drs |
| 137 | } |
| 138 | |
| 139 | func parseTOSTCByte(w io.Writer, r io.Reader) error { |
| 140 | dec := xml.NewDecoder(r) |
| 141 | var ttb tosTCByte |
| 142 | if err := dec.Decode(&ttb); err != nil { |
| 143 | return err |
| 144 | } |
| 145 | trs := ttb.escape() |
| 146 | fmt.Fprintf(w, "// %s, Updated: %s\n", ttb.Title, ttb.Updated) |
| 147 | fmt.Fprintf(w, "const (\n") |
| 148 | for _, tr := range trs { |
| 149 | fmt.Fprintf(w, "%s = %#x", tr.Keyword, tr.Value) |
| 150 | fmt.Fprintf(w, "// %s\n", tr.OrigKeyword) |
| 151 | } |
| 152 | fmt.Fprintf(w, ")\n") |
| 153 | return nil |
| 154 | } |
| 155 | |
| 156 | type tosTCByte struct { |
| 157 | XMLName xml.Name `xml:"registry"` |
| 158 | Title string `xml:"title"` |
| 159 | Updated string `xml:"updated"` |
| 160 | Note string `xml:"note"` |
| 161 | RegTitle string `xml:"registry>title"` |
| 162 | Records []struct { |
| 163 | Binary string `xml:"binary"` |
| 164 | Keyword string `xml:"keyword"` |
| 165 | } `xml:"registry>record"` |
| 166 | } |
| 167 | |
| 168 | type canonTOSTCByteRecord struct { |
| 169 | OrigKeyword string |
| 170 | Keyword string |
| 171 | Value int |
| 172 | } |
| 173 | |
| 174 | func (ttb *tosTCByte) escape() []canonTOSTCByteRecord { |
| 175 | trs := make([]canonTOSTCByteRecord, len(ttb.Records)) |
| 176 | sr := strings.NewReplacer( |
| 177 | "Capable", "", |
| 178 | "(", "", |
| 179 | ")", "", |
| 180 | "+", "", |
| 181 | "-", "", |
| 182 | "/", "", |
| 183 | ".", "", |
| 184 | " ", "", |
| 185 | ) |
| 186 | for i, tr := range ttb.Records { |
| 187 | s := strings.TrimSpace(tr.Keyword) |
| 188 | trs[i].OrigKeyword = s |
| 189 | ss := strings.Split(s, " ") |
| 190 | if len(ss) > 1 { |
| 191 | trs[i].Keyword = strings.Join(ss[1:], " ") |
| 192 | } else { |
| 193 | trs[i].Keyword = ss[0] |
| 194 | } |
| 195 | trs[i].Keyword = sr.Replace(trs[i].Keyword) |
| 196 | n, err := strconv.ParseUint(tr.Binary, 2, 8) |
| 197 | if err != nil { |
| 198 | continue |
| 199 | } |
| 200 | trs[i].Value = int(n) |
| 201 | } |
| 202 | return trs |
| 203 | } |
| 204 | |
| 205 | func parseProtocolNumbers(w io.Writer, r io.Reader) error { |
| 206 | dec := xml.NewDecoder(r) |
| 207 | var pn protocolNumbers |
| 208 | if err := dec.Decode(&pn); err != nil { |
| 209 | return err |
| 210 | } |
| 211 | prs := pn.escape() |
| 212 | prs = append([]canonProtocolRecord{{ |
| 213 | Name: "IP", |
| 214 | Descr: "IPv4 encapsulation, pseudo protocol number", |
| 215 | Value: 0, |
| 216 | }}, prs...) |
| 217 | fmt.Fprintf(w, "// %s, Updated: %s\n", pn.Title, pn.Updated) |
| 218 | fmt.Fprintf(w, "const (\n") |
| 219 | for _, pr := range prs { |
| 220 | if pr.Name == "" { |
| 221 | continue |
| 222 | } |
| 223 | fmt.Fprintf(w, "Protocol%s = %d", pr.Name, pr.Value) |
| 224 | s := pr.Descr |
| 225 | if s == "" { |
| 226 | s = pr.OrigName |
| 227 | } |
| 228 | fmt.Fprintf(w, "// %s\n", s) |
| 229 | } |
| 230 | fmt.Fprintf(w, ")\n") |
| 231 | return nil |
| 232 | } |
| 233 | |
| 234 | type protocolNumbers struct { |
| 235 | XMLName xml.Name `xml:"registry"` |
| 236 | Title string `xml:"title"` |
| 237 | Updated string `xml:"updated"` |
| 238 | RegTitle string `xml:"registry>title"` |
| 239 | Note string `xml:"registry>note"` |
| 240 | Records []struct { |
| 241 | Value string `xml:"value"` |
| 242 | Name string `xml:"name"` |
| 243 | Descr string `xml:"description"` |
| 244 | } `xml:"registry>record"` |
| 245 | } |
| 246 | |
| 247 | type canonProtocolRecord struct { |
| 248 | OrigName string |
| 249 | Name string |
| 250 | Descr string |
| 251 | Value int |
| 252 | } |
| 253 | |
| 254 | func (pn *protocolNumbers) escape() []canonProtocolRecord { |
| 255 | prs := make([]canonProtocolRecord, len(pn.Records)) |
| 256 | sr := strings.NewReplacer( |
| 257 | "-in-", "in", |
| 258 | "-within-", "within", |
| 259 | "-over-", "over", |
| 260 | "+", "P", |
| 261 | "-", "", |
| 262 | "/", "", |
| 263 | ".", "", |
| 264 | " ", "", |
| 265 | ) |
| 266 | for i, pr := range pn.Records { |
| 267 | if strings.Contains(pr.Name, "Deprecated") || |
| 268 | strings.Contains(pr.Name, "deprecated") { |
| 269 | continue |
| 270 | } |
| 271 | prs[i].OrigName = pr.Name |
| 272 | s := strings.TrimSpace(pr.Name) |
| 273 | switch pr.Name { |
| 274 | case "ISIS over IPv4": |
| 275 | prs[i].Name = "ISIS" |
| 276 | case "manet": |
| 277 | prs[i].Name = "MANET" |
| 278 | default: |
| 279 | prs[i].Name = sr.Replace(s) |
| 280 | } |
| 281 | ss := strings.Split(pr.Descr, "\n") |
| 282 | for i := range ss { |
| 283 | ss[i] = strings.TrimSpace(ss[i]) |
| 284 | } |
| 285 | if len(ss) > 1 { |
| 286 | prs[i].Descr = strings.Join(ss, " ") |
| 287 | } else { |
| 288 | prs[i].Descr = ss[0] |
| 289 | } |
| 290 | prs[i].Value, _ = strconv.Atoi(pr.Value) |
| 291 | } |
| 292 | return prs |
| 293 | } |