← Back to branch summary

~john-koepi/ubuntu/trusty/golang/default

« back to all changes in this revision

Viewing changes to src/pkg/net/dnsmsg.go

  • Committer: Bazaar Package Importer
  • Author(s): Ondřej Surý
  • Date: 2011-08-03 17:04:59 UTC
  • mfrom: (14.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20110803170459-wzd99m3567y80ila
Tags: 1:59-1
http://bugs.debian.org/634270
* Imported Upstream version 59
* Refresh patches to a new release
* Fix FTBFS on ARM (Closes: #634270)
* Update version.bash to work with Debian packaging and not hg
  repository

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/net/dnsmsg.go
93
93
 
94
94
// DNS queries.
95
95
type dnsQuestion struct {
96
 
        Name   string "domain-name" // "domain-name" specifies encoding; see packers below
 
96
        Name   string `net:"domain-name"` // `net:"domain-name"` specifies encoding; see packers below
97
97
        Qtype  uint16
98
98
        Qclass uint16
99
99
}
102
102
// There are many types of messages,
103
103
// but they all share the same header.
104
104
type dnsRR_Header struct {
105
 
        Name     string "domain-name"
 
105
        Name     string `net:"domain-name"`
106
106
        Rrtype   uint16
107
107
        Class    uint16
108
108
        Ttl      uint32
121
121
 
122
122
type dnsRR_CNAME struct {
123
123
        Hdr   dnsRR_Header
124
 
        Cname string "domain-name"
 
124
        Cname string `net:"domain-name"`
125
125
}
126
126
 
127
127
func (rr *dnsRR_CNAME) Header() *dnsRR_Header {
140
140
 
141
141
type dnsRR_MB struct {
142
142
        Hdr dnsRR_Header
143
 
        Mb  string "domain-name"
 
143
        Mb  string `net:"domain-name"`
144
144
}
145
145
 
146
146
func (rr *dnsRR_MB) Header() *dnsRR_Header {
149
149
 
150
150
type dnsRR_MG struct {
151
151
        Hdr dnsRR_Header
152
 
        Mg  string "domain-name"
 
152
        Mg  string `net:"domain-name"`
153
153
}
154
154
 
155
155
func (rr *dnsRR_MG) Header() *dnsRR_Header {
158
158
 
159
159
type dnsRR_MINFO struct {
160
160
        Hdr   dnsRR_Header
161
 
        Rmail string "domain-name"
162
 
        Email string "domain-name"
 
161
        Rmail string `net:"domain-name"`
 
162
        Email string `net:"domain-name"`
163
163
}
164
164
 
165
165
func (rr *dnsRR_MINFO) Header() *dnsRR_Header {
168
168
 
169
169
type dnsRR_MR struct {
170
170
        Hdr dnsRR_Header
171
 
        Mr  string "domain-name"
 
171
        Mr  string `net:"domain-name"`
172
172
}
173
173
 
174
174
func (rr *dnsRR_MR) Header() *dnsRR_Header {
178
178
type dnsRR_MX struct {
179
179
        Hdr  dnsRR_Header
180
180
        Pref uint16
181
 
        Mx   string "domain-name"
 
181
        Mx   string `net:"domain-name"`
182
182
}
183
183
 
184
184
func (rr *dnsRR_MX) Header() *dnsRR_Header {
187
187
 
188
188
type dnsRR_NS struct {
189
189
        Hdr dnsRR_Header
190
 
        Ns  string "domain-name"
 
190
        Ns  string `net:"domain-name"`
191
191
}
192
192
 
193
193
func (rr *dnsRR_NS) Header() *dnsRR_Header {
196
196
 
197
197
type dnsRR_PTR struct {
198
198
        Hdr dnsRR_Header
199
 
        Ptr string "domain-name"
 
199
        Ptr string `net:"domain-name"`
200
200
}
201
201
 
202
202
func (rr *dnsRR_PTR) Header() *dnsRR_Header {
205
205
 
206
206
type dnsRR_SOA struct {
207
207
        Hdr     dnsRR_Header
208
 
        Ns      string "domain-name"
209
 
        Mbox    string "domain-name"
 
208
        Ns      string `net:"domain-name"`
 
209
        Mbox    string `net:"domain-name"`
210
210
        Serial  uint32
211
211
        Refresh uint32
212
212
        Retry   uint32
232
232
        Priority uint16
233
233
        Weight   uint16
234
234
        Port     uint16
235
 
        Target   string "domain-name"
 
235
        Target   string `net:"domain-name"`
236
236
}
237
237
 
238
238
func (rr *dnsRR_SRV) Header() *dnsRR_Header {
241
241
 
242
242
type dnsRR_A struct {
243
243
        Hdr dnsRR_Header
244
 
        A   uint32 "ipv4"
 
244
        A   uint32 `net:"ipv4"`
245
245
}
246
246
 
247
247
func (rr *dnsRR_A) Header() *dnsRR_Header {
250
250
 
251
251
type dnsRR_AAAA struct {
252
252
        Hdr  dnsRR_Header
253
 
        AAAA [16]byte "ipv6"
 
253
        AAAA [16]byte `net:"ipv6"`
254
254
}
255
255
 
256
256
func (rr *dnsRR_AAAA) Header() *dnsRR_Header {
394
394
                f := val.Type().Field(i)
395
395
                switch fv := val.Field(i); fv.Kind() {
396
396
                default:
397
 
                BadType:
398
397
                        fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
399
398
                        return len(msg), false
400
399
                case reflect.Struct:
419
418
                        off += 4
420
419
                case reflect.Array:
421
420
                        if fv.Type().Elem().Kind() != reflect.Uint8 {
422
 
                                goto BadType
 
421
                                fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
 
422
                                return len(msg), false
423
423
                        }
424
424
                        n := fv.Len()
425
425
                        if off+n > len(msg) {
435
435
                        default:
436
436
                                fmt.Fprintf(os.Stderr, "net: dns: unknown string tag %v", f.Tag)
437
437
                                return len(msg), false
438
 
                        case "domain-name":
 
438
                        case `net:"domain-name"`:
439
439
                                off, ok = packDomainName(s, msg, off)
440
440
                                if !ok {
441
441
                                        return len(msg), false
471
471
                f := val.Type().Field(i)
472
472
                switch fv := val.Field(i); fv.Kind() {
473
473
                default:
474
 
                BadType:
475
474
                        fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
476
475
                        return len(msg), false
477
476
                case reflect.Struct:
492
491
                        off += 4
493
492
                case reflect.Array:
494
493
                        if fv.Type().Elem().Kind() != reflect.Uint8 {
495
 
                                goto BadType
 
494
                                fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
 
495
                                return len(msg), false
496
496
                        }
497
497
                        n := fv.Len()
498
498
                        if off+n > len(msg) {
506
506
                        default:
507
507
                                fmt.Fprintf(os.Stderr, "net: dns: unknown string tag %v", f.Tag)
508
508
                                return len(msg), false
509
 
                        case "domain-name":
 
509
                        case `net:"domain-name"`:
510
510
                                s, off, ok = unpackDomainName(msg, off)
511
511
                                if !ok {
512
512
                                        return len(msg), false
536
536
}
537
537
 
538
538
// Generic struct printer.
539
 
// Doesn't care about the string tag "domain-name",
540
 
// but does look for an "ipv4" tag on uint32 variables
541
 
// and the "ipv6" tag on array variables,
 
539
// Doesn't care about the string tag `net:"domain-name"`,
 
540
// but does look for an `net:"ipv4"` tag on uint32 variables
 
541
// and the `net:"ipv6"` tag on array variables,
542
542
// printing them as IP addresses.
543
543
func printStructValue(val reflect.Value) string {
544
544
        s := "{"
553
553
                fval := val.Field(i)
554
554
                if fv := fval; fv.Kind() == reflect.Struct {
555
555
                        s += printStructValue(fv)
556
 
                } else if fv := fval; (fv.Kind() == reflect.Uint || fv.Kind() == reflect.Uint8 || fv.Kind() == reflect.Uint16 || fv.Kind() == reflect.Uint32 || fv.Kind() == reflect.Uint64 || fv.Kind() == reflect.Uintptr) && f.Tag == "ipv4" {
 
556
                } else if fv := fval; (fv.Kind() == reflect.Uint || fv.Kind() == reflect.Uint8 || fv.Kind() == reflect.Uint16 || fv.Kind() == reflect.Uint32 || fv.Kind() == reflect.Uint64 || fv.Kind() == reflect.Uintptr) && f.Tag == `net:"ipv4"` {
557
557
                        i := fv.Uint()
558
558
                        s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String()
559
 
                } else if fv := fval; fv.Kind() == reflect.Array && f.Tag == "ipv6" {
 
559
                } else if fv := fval; fv.Kind() == reflect.Array && f.Tag == `net:"ipv6"` {
560
560
                        i := fv.Interface().([]byte)
561
561
                        s += IP(i).String()
562
562
                } else {