Source file
src/net/ip.go
Documentation: net
1
2
3
4
5
6
7
8
9
10
11
12
13 package net
14
15 import _ "unsafe"
16
17
18 const (
19 IPv4len = 4
20 IPv6len = 16
21 )
22
23
24
25
26
27
28
29
30
31
32 type IP []byte
33
34
35 type IPMask []byte
36
37
38 type IPNet struct {
39 IP IP
40 Mask IPMask
41 }
42
43
44
45 func IPv4(a, b, c, d byte) IP {
46 p := make(IP, IPv6len)
47 copy(p, v4InV6Prefix)
48 p[12] = a
49 p[13] = b
50 p[14] = c
51 p[15] = d
52 return p
53 }
54
55 var v4InV6Prefix = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}
56
57
58
59 func IPv4Mask(a, b, c, d byte) IPMask {
60 p := make(IPMask, IPv4len)
61 p[0] = a
62 p[1] = b
63 p[2] = c
64 p[3] = d
65 return p
66 }
67
68
69
70
71 func CIDRMask(ones, bits int) IPMask {
72 if bits != 8*IPv4len && bits != 8*IPv6len {
73 return nil
74 }
75 if ones < 0 || ones > bits {
76 return nil
77 }
78 l := bits / 8
79 m := make(IPMask, l)
80 n := uint(ones)
81 for i := 0; i < l; i++ {
82 if n >= 8 {
83 m[i] = 0xff
84 n -= 8
85 continue
86 }
87 m[i] = ^byte(0xff >> n)
88 n = 0
89 }
90 return m
91 }
92
93
94 var (
95 IPv4bcast = IPv4(255, 255, 255, 255)
96 IPv4allsys = IPv4(224, 0, 0, 1)
97 IPv4allrouter = IPv4(224, 0, 0, 2)
98 IPv4zero = IPv4(0, 0, 0, 0)
99 )
100
101
102 var (
103 IPv6zero = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
104 IPv6unspecified = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
105 IPv6loopback = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
106 IPv6interfacelocalallnodes = IP{0xff, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}
107 IPv6linklocalallnodes = IP{0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}
108 IPv6linklocalallrouters = IP{0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x02}
109 )
110
111
112
113 func (ip IP) IsUnspecified() bool {
114 return ip.Equal(IPv4zero) || ip.Equal(IPv6unspecified)
115 }
116
117
118 func (ip IP) IsLoopback() bool {
119 if ip4 := ip.To4(); ip4 != nil {
120 return ip4[0] == 127
121 }
122 return ip.Equal(IPv6loopback)
123 }
124
125
126 func (ip IP) IsMulticast() bool {
127 if ip4 := ip.To4(); ip4 != nil {
128 return ip4[0]&0xf0 == 0xe0
129 }
130 return len(ip) == IPv6len && ip[0] == 0xff
131 }
132
133
134
135 func (ip IP) IsInterfaceLocalMulticast() bool {
136 return len(ip) == IPv6len && ip[0] == 0xff && ip[1]&0x0f == 0x01
137 }
138
139
140
141 func (ip IP) IsLinkLocalMulticast() bool {
142 if ip4 := ip.To4(); ip4 != nil {
143 return ip4[0] == 224 && ip4[1] == 0 && ip4[2] == 0
144 }
145 return len(ip) == IPv6len && ip[0] == 0xff && ip[1]&0x0f == 0x02
146 }
147
148
149
150 func (ip IP) IsLinkLocalUnicast() bool {
151 if ip4 := ip.To4(); ip4 != nil {
152 return ip4[0] == 169 && ip4[1] == 254
153 }
154 return len(ip) == IPv6len && ip[0] == 0xfe && ip[1]&0xc0 == 0x80
155 }
156
157
158
159
160
161
162
163
164
165 func (ip IP) IsGlobalUnicast() bool {
166 return (len(ip) == IPv4len || len(ip) == IPv6len) &&
167 !ip.Equal(IPv4bcast) &&
168 !ip.IsUnspecified() &&
169 !ip.IsLoopback() &&
170 !ip.IsMulticast() &&
171 !ip.IsLinkLocalUnicast()
172 }
173
174
175 func isZeros(p IP) bool {
176 for i := 0; i < len(p); i++ {
177 if p[i] != 0 {
178 return false
179 }
180 }
181 return true
182 }
183
184
185
186 func (ip IP) To4() IP {
187 if len(ip) == IPv4len {
188 return ip
189 }
190 if len(ip) == IPv6len &&
191 isZeros(ip[0:10]) &&
192 ip[10] == 0xff &&
193 ip[11] == 0xff {
194 return ip[12:16]
195 }
196 return nil
197 }
198
199
200
201 func (ip IP) To16() IP {
202 if len(ip) == IPv4len {
203 return IPv4(ip[0], ip[1], ip[2], ip[3])
204 }
205 if len(ip) == IPv6len {
206 return ip
207 }
208 return nil
209 }
210
211
212 var (
213 classAMask = IPv4Mask(0xff, 0, 0, 0)
214 classBMask = IPv4Mask(0xff, 0xff, 0, 0)
215 classCMask = IPv4Mask(0xff, 0xff, 0xff, 0)
216 )
217
218
219
220
221 func (ip IP) DefaultMask() IPMask {
222 if ip = ip.To4(); ip == nil {
223 return nil
224 }
225 switch true {
226 case ip[0] < 0x80:
227 return classAMask
228 case ip[0] < 0xC0:
229 return classBMask
230 default:
231 return classCMask
232 }
233 }
234
235 func allFF(b []byte) bool {
236 for _, c := range b {
237 if c != 0xff {
238 return false
239 }
240 }
241 return true
242 }
243
244
245 func (ip IP) Mask(mask IPMask) IP {
246 if len(mask) == IPv6len && len(ip) == IPv4len && allFF(mask[:12]) {
247 mask = mask[12:]
248 }
249 if len(mask) == IPv4len && len(ip) == IPv6len && bytesEqual(ip[:12], v4InV6Prefix) {
250 ip = ip[12:]
251 }
252 n := len(ip)
253 if n != len(mask) {
254 return nil
255 }
256 out := make(IP, n)
257 for i := 0; i < n; i++ {
258 out[i] = ip[i] & mask[i]
259 }
260 return out
261 }
262
263
264
265
266 func ubtoa(dst []byte, start int, v byte) int {
267 if v < 10 {
268 dst[start] = v + '0'
269 return 1
270 } else if v < 100 {
271 dst[start+1] = v%10 + '0'
272 dst[start] = v/10 + '0'
273 return 2
274 }
275
276 dst[start+2] = v%10 + '0'
277 dst[start+1] = (v/10)%10 + '0'
278 dst[start] = v/100 + '0'
279 return 3
280 }
281
282
283
284
285
286
287
288 func (ip IP) String() string {
289 p := ip
290
291 if len(ip) == 0 {
292 return "<nil>"
293 }
294
295
296 if p4 := p.To4(); len(p4) == IPv4len {
297 const maxIPv4StringLen = len("255.255.255.255")
298 b := make([]byte, maxIPv4StringLen)
299
300 n := ubtoa(b, 0, p4[0])
301 b[n] = '.'
302 n++
303
304 n += ubtoa(b, n, p4[1])
305 b[n] = '.'
306 n++
307
308 n += ubtoa(b, n, p4[2])
309 b[n] = '.'
310 n++
311
312 n += ubtoa(b, n, p4[3])
313 return string(b[:n])
314 }
315 if len(p) != IPv6len {
316 return "?" + hexString(ip)
317 }
318
319
320 e0 := -1
321 e1 := -1
322 for i := 0; i < IPv6len; i += 2 {
323 j := i
324 for j < IPv6len && p[j] == 0 && p[j+1] == 0 {
325 j += 2
326 }
327 if j > i && j-i > e1-e0 {
328 e0 = i
329 e1 = j
330 i = j
331 }
332 }
333
334 if e1-e0 <= 2 {
335 e0 = -1
336 e1 = -1
337 }
338
339 const maxLen = len("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
340 b := make([]byte, 0, maxLen)
341
342
343 for i := 0; i < IPv6len; i += 2 {
344 if i == e0 {
345 b = append(b, ':', ':')
346 i = e1
347 if i >= IPv6len {
348 break
349 }
350 } else if i > 0 {
351 b = append(b, ':')
352 }
353 b = appendHex(b, (uint32(p[i])<<8)|uint32(p[i+1]))
354 }
355 return string(b)
356 }
357
358 func hexString(b []byte) string {
359 s := make([]byte, len(b)*2)
360 for i, tn := range b {
361 s[i*2], s[i*2+1] = hexDigit[tn>>4], hexDigit[tn&0xf]
362 }
363 return string(s)
364 }
365
366
367
368 func ipEmptyString(ip IP) string {
369 if len(ip) == 0 {
370 return ""
371 }
372 return ip.String()
373 }
374
375
376
377
378 func (ip IP) MarshalText() ([]byte, error) {
379 if len(ip) == 0 {
380 return []byte(""), nil
381 }
382 if len(ip) != IPv4len && len(ip) != IPv6len {
383 return nil, &AddrError{Err: "invalid IP address", Addr: hexString(ip)}
384 }
385 return []byte(ip.String()), nil
386 }
387
388
389
390 func (ip *IP) UnmarshalText(text []byte) error {
391 if len(text) == 0 {
392 *ip = nil
393 return nil
394 }
395 s := string(text)
396 x := ParseIP(s)
397 if x == nil {
398 return &ParseError{Type: "IP address", Text: s}
399 }
400 *ip = x
401 return nil
402 }
403
404
405
406
407 func (ip IP) Equal(x IP) bool {
408 if len(ip) == len(x) {
409 return bytesEqual(ip, x)
410 }
411 if len(ip) == IPv4len && len(x) == IPv6len {
412 return bytesEqual(x[0:12], v4InV6Prefix) && bytesEqual(ip, x[12:])
413 }
414 if len(ip) == IPv6len && len(x) == IPv4len {
415 return bytesEqual(ip[0:12], v4InV6Prefix) && bytesEqual(ip[12:], x)
416 }
417 return false
418 }
419
420
421
422 func bytesEqual(x, y []byte) bool
423
424 func (ip IP) matchAddrFamily(x IP) bool {
425 return ip.To4() != nil && x.To4() != nil || ip.To16() != nil && ip.To4() == nil && x.To16() != nil && x.To4() == nil
426 }
427
428
429
430 func simpleMaskLength(mask IPMask) int {
431 var n int
432 for i, v := range mask {
433 if v == 0xff {
434 n += 8
435 continue
436 }
437
438
439 for v&0x80 != 0 {
440 n++
441 v <<= 1
442 }
443
444 if v != 0 {
445 return -1
446 }
447 for i++; i < len(mask); i++ {
448 if mask[i] != 0 {
449 return -1
450 }
451 }
452 break
453 }
454 return n
455 }
456
457
458
459
460 func (m IPMask) Size() (ones, bits int) {
461 ones, bits = simpleMaskLength(m), len(m)*8
462 if ones == -1 {
463 return 0, 0
464 }
465 return
466 }
467
468
469 func (m IPMask) String() string {
470 if len(m) == 0 {
471 return "<nil>"
472 }
473 return hexString(m)
474 }
475
476 func networkNumberAndMask(n *IPNet) (ip IP, m IPMask) {
477 if ip = n.IP.To4(); ip == nil {
478 ip = n.IP
479 if len(ip) != IPv6len {
480 return nil, nil
481 }
482 }
483 m = n.Mask
484 switch len(m) {
485 case IPv4len:
486 if len(ip) != IPv4len {
487 return nil, nil
488 }
489 case IPv6len:
490 if len(ip) == IPv4len {
491 m = m[12:]
492 }
493 default:
494 return nil, nil
495 }
496 return
497 }
498
499
500 func (n *IPNet) Contains(ip IP) bool {
501 nn, m := networkNumberAndMask(n)
502 if x := ip.To4(); x != nil {
503 ip = x
504 }
505 l := len(ip)
506 if l != len(nn) {
507 return false
508 }
509 for i := 0; i < l; i++ {
510 if nn[i]&m[i] != ip[i]&m[i] {
511 return false
512 }
513 }
514 return true
515 }
516
517
518 func (n *IPNet) Network() string { return "ip+net" }
519
520
521
522
523
524
525
526 func (n *IPNet) String() string {
527 nn, m := networkNumberAndMask(n)
528 if nn == nil || m == nil {
529 return "<nil>"
530 }
531 l := simpleMaskLength(m)
532 if l == -1 {
533 return nn.String() + "/" + m.String()
534 }
535 return nn.String() + "/" + uitoa(uint(l))
536 }
537
538
539 func parseIPv4(s string) IP {
540 var p [IPv4len]byte
541 for i := 0; i < IPv4len; i++ {
542 if len(s) == 0 {
543
544 return nil
545 }
546 if i > 0 {
547 if s[0] != '.' {
548 return nil
549 }
550 s = s[1:]
551 }
552 n, c, ok := dtoi(s)
553 if !ok || n > 0xFF {
554 return nil
555 }
556 s = s[c:]
557 p[i] = byte(n)
558 }
559 if len(s) != 0 {
560 return nil
561 }
562 return IPv4(p[0], p[1], p[2], p[3])
563 }
564
565
566
567 func parseIPv6Zone(s string) (IP, string) {
568 s, zone := splitHostZone(s)
569 return parseIPv6(s), zone
570 }
571
572
573
574 func parseIPv6(s string) (ip IP) {
575 ip = make(IP, IPv6len)
576 ellipsis := -1
577
578
579 if len(s) >= 2 && s[0] == ':' && s[1] == ':' {
580 ellipsis = 0
581 s = s[2:]
582
583 if len(s) == 0 {
584 return ip
585 }
586 }
587
588
589 i := 0
590 for i < IPv6len {
591
592 n, c, ok := xtoi(s)
593 if !ok || n > 0xFFFF {
594 return nil
595 }
596
597
598 if c < len(s) && s[c] == '.' {
599 if ellipsis < 0 && i != IPv6len-IPv4len {
600
601 return nil
602 }
603 if i+IPv4len > IPv6len {
604
605 return nil
606 }
607 ip4 := parseIPv4(s)
608 if ip4 == nil {
609 return nil
610 }
611 ip[i] = ip4[12]
612 ip[i+1] = ip4[13]
613 ip[i+2] = ip4[14]
614 ip[i+3] = ip4[15]
615 s = ""
616 i += IPv4len
617 break
618 }
619
620
621 ip[i] = byte(n >> 8)
622 ip[i+1] = byte(n)
623 i += 2
624
625
626 s = s[c:]
627 if len(s) == 0 {
628 break
629 }
630
631
632 if s[0] != ':' || len(s) == 1 {
633 return nil
634 }
635 s = s[1:]
636
637
638 if s[0] == ':' {
639 if ellipsis >= 0 {
640 return nil
641 }
642 ellipsis = i
643 s = s[1:]
644 if len(s) == 0 {
645 break
646 }
647 }
648 }
649
650
651 if len(s) != 0 {
652 return nil
653 }
654
655
656 if i < IPv6len {
657 if ellipsis < 0 {
658 return nil
659 }
660 n := IPv6len - i
661 for j := i - 1; j >= ellipsis; j-- {
662 ip[j+n] = ip[j]
663 }
664 for j := ellipsis + n - 1; j >= ellipsis; j-- {
665 ip[j] = 0
666 }
667 } else if ellipsis >= 0 {
668
669 return nil
670 }
671 return ip
672 }
673
674
675
676
677
678
679 func ParseIP(s string) IP {
680 for i := 0; i < len(s); i++ {
681 switch s[i] {
682 case '.':
683 return parseIPv4(s)
684 case ':':
685 return parseIPv6(s)
686 }
687 }
688 return nil
689 }
690
691
692
693 func parseIPZone(s string) (IP, string) {
694 for i := 0; i < len(s); i++ {
695 switch s[i] {
696 case '.':
697 return parseIPv4(s), ""
698 case ':':
699 return parseIPv6Zone(s)
700 }
701 }
702 return nil, ""
703 }
704
705
706
707
708
709
710
711
712
713 func ParseCIDR(s string) (IP, *IPNet, error) {
714 i := byteIndex(s, '/')
715 if i < 0 {
716 return nil, nil, &ParseError{Type: "CIDR address", Text: s}
717 }
718 addr, mask := s[:i], s[i+1:]
719 iplen := IPv4len
720 ip := parseIPv4(addr)
721 if ip == nil {
722 iplen = IPv6len
723 ip = parseIPv6(addr)
724 }
725 n, i, ok := dtoi(mask)
726 if ip == nil || !ok || i != len(mask) || n < 0 || n > 8*iplen {
727 return nil, nil, &ParseError{Type: "CIDR address", Text: s}
728 }
729 m := CIDRMask(n, 8*iplen)
730 return ip, &IPNet{IP: ip.Mask(m), Mask: m}, nil
731 }
732
View as plain text