| Left: | ||
| Right: |
| OLD | NEW |
|---|---|
| (Empty) | |
| 1 // Copyright 2012 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 package ipv4_test | |
| 6 | |
| 7 import ( | |
| 8 "code.google.com/p/go.net/ipv4" | |
| 9 "log" | |
| 10 "net" | |
| 11 ) | |
| 12 | |
| 13 func ExampleUnicastTCPListener() { | |
| 14 ln, err := net.Listen("tcp4", "0.0.0.0:1024") | |
| 15 if err != nil { | |
| 16 log.Fatal(err) | |
| 17 } | |
| 18 defer ln.Close() | |
| 19 for { | |
| 20 c, err := ln.Accept() | |
| 21 if err != nil { | |
| 22 log.Fatal(err) | |
| 23 } | |
| 24 go func(c net.Conn) { | |
| 25 defer c.Close() | |
| 26 err := ipv4.NewConn(c).SetTOS(ipv4.DSCP_AF11) | |
| 27 if err != nil { | |
| 28 log.Fatal(err) | |
| 29 } | |
| 30 _, err = c.Write([]byte("HELLO-R-U-THERE-ACK")) | |
| 31 if err != nil { | |
| 32 log.Fatal(err) | |
| 33 } | |
| 34 }(c) | |
| 35 } | |
| 36 } | |
| 37 | |
| 38 func ExampleMulticastUDPListener() { | |
| 39 en0, err := net.InterfaceByName("en0") | |
| 40 if err != nil { | |
| 41 log.Fatal(err) | |
| 42 } | |
| 43 en1, err := net.InterfaceByIndex(911) | |
| 44 if err != nil { | |
| 45 log.Fatal(err) | |
| 46 } | |
| 47 group := net.IPv4(224, 0, 0, 250) | |
| 48 | |
| 49 c, err := net.ListenPacket("udp4", "0.0.0.0:1024") | |
| 50 if err != nil { | |
| 51 log.Fatal(err) | |
| 52 } | |
| 53 defer c.Close() | |
| 54 | |
| 55 p := ipv4.NewPacketConn(c) | |
| 56 err = p.JoinGroup(en0, &net.UDPAddr{IP: group}) | |
| 57 if err != nil { | |
| 58 log.Fatal(err) | |
| 59 } | |
| 60 err = p.JoinGroup(en1, &net.UDPAddr{IP: group}) | |
| 61 if err != nil { | |
| 62 log.Fatal(err) | |
| 63 } | |
| 64 | |
| 65 err = p.SetControlMessage(ipv4.FlagDst, true) | |
| 66 if err != nil { | |
| 67 log.Fatal(err) | |
| 68 } | |
| 69 | |
| 70 b := make([]byte, 1500) | |
| 71 for { | |
| 72 n, cm, src, err := p.Read(b) | |
| 73 if err != nil { | |
| 74 log.Fatal(err) | |
| 75 } | |
| 76 if cm.Dst.IsMulticast() { | |
| 77 if cm.Dst.Equal(group) { | |
| 78 // joined group, do something | |
| 79 } else { | |
| 80 // unknown group, discard | |
| 81 continue | |
| 82 } | |
| 83 } | |
| 84 p.SetTOS(ipv4.DSCP_CS7) | |
| 85 p.SetTTL(16) | |
| 86 _, err = p.Write(b[:n], nil, src) | |
| 87 if err != nil { | |
| 88 log.Fatal(err) | |
| 89 } | |
| 90 dst := &net.UDPAddr{IP: group, Port: 1024} | |
| 91 for _, ifi := range []*net.Interface{en0, en1} { | |
| 92 err := p.SetMulticastInterface(ifi) | |
| 93 if err != nil { | |
| 94 log.Fatal(err) | |
| 95 } | |
| 96 p.SetMulticastTTL(2) | |
| 97 _, err = p.Write(b[:n], nil, dst) | |
| 98 if err != nil { | |
| 99 log.Fatal(err) | |
| 100 } | |
| 101 } | |
| 102 } | |
| 103 | |
| 104 err = p.LeaveGroup(en1, &net.UDPAddr{IP: group}) | |
| 105 if err != nil { | |
| 106 log.Fatal(err) | |
| 107 } | |
| 108 newgroup := net.IPv4(224, 0, 0, 249) | |
| 109 err = p.JoinGroup(en1, &net.UDPAddr{IP: newgroup}) | |
| 110 if err != nil { | |
| 111 log.Fatal(err) | |
| 112 } | |
| 113 } | |
| 114 | |
| 115 type OSPFHeader struct { | |
| 116 Version byte | |
| 117 Type byte | |
| 118 Len uint16 | |
| 119 RouterID uint32 | |
| 120 AreaID uint32 | |
| 121 Checksum uint16 | |
| 122 } | |
| 123 | |
| 124 const ( | |
| 125 OSPFHeaderLen = 14 | |
| 126 OSPFHelloHeaderLen = 20 | |
| 127 OSPF_VERSION = 2 | |
| 128 OSPF_TYPE_HELLO = iota + 1 | |
| 129 OSPF_TYPE_DB_DESCRIPTION | |
| 130 OSPF_TYPE_LS_REQUEST | |
| 131 OSPF_TYPE_LS_UPDATE | |
| 132 OSPF_TYPE_LS_ACK | |
| 133 ) | |
| 134 | |
| 135 var ( | |
| 136 AllSPFRouters = net.IPv4(224, 0, 0, 5) | |
|
dave_cheney.net
2012/09/06 12:40:36
AllOSPFRouters ?
mikio
2012/09/06 15:09:16
I'd prefer the term in RFC 2328 because this is ju
| |
| 137 AllDesignatedRouters = net.IPv4(224, 0, 0, 6) | |
| 138 ) | |
| 139 | |
| 140 func ExampleIPOSPFListener() { | |
| 141 var ifs []*net.Interface | |
| 142 en0, err := net.InterfaceByName("en0") | |
| 143 if err != nil { | |
| 144 log.Fatal(err) | |
| 145 } | |
| 146 ifs = append(ifs, en0) | |
| 147 en1, err := net.InterfaceByIndex(911) | |
| 148 if err != nil { | |
| 149 log.Fatal(err) | |
| 150 } | |
| 151 ifs = append(ifs, en1) | |
| 152 | |
| 153 c, err := net.ListenPacket("ip4:89", "0.0.0.0") | |
| 154 if err != nil { | |
| 155 log.Fatal(err) | |
| 156 } | |
| 157 defer c.Close() | |
| 158 | |
| 159 r, err := ipv4.NewRawConn(c) | |
| 160 if err != nil { | |
| 161 log.Fatal(err) | |
| 162 } | |
| 163 for _, ifi := range ifs { | |
| 164 err := r.JoinGroup(ifi, &net.IPAddr{IP: AllSPFRouters}) | |
| 165 if err != nil { | |
| 166 log.Fatal(err) | |
| 167 } | |
| 168 err = r.JoinGroup(ifi, &net.IPAddr{IP: AllDesignatedRouters}) | |
| 169 if err != nil { | |
| 170 log.Fatal(err) | |
| 171 } | |
| 172 } | |
| 173 | |
| 174 err = r.SetControlMessage(ipv4.FlagDst|ipv4.FlagInterface, true) | |
| 175 if err != nil { | |
| 176 log.Fatal(err) | |
| 177 } | |
| 178 r.SetTOS(ipv4.DSCP_CS6) | |
| 179 | |
| 180 parseOSPFHeader := func(b []byte) *OSPFHeader { | |
| 181 if len(b) < OSPFHeaderLen { | |
| 182 return nil | |
| 183 } | |
| 184 return &OSPFHeader{ | |
| 185 Version: b[0], | |
| 186 Type: b[1], | |
| 187 Len: uint16(b[2])<<8 | uint16(b[3]), | |
| 188 RouterID: uint32(b[4])<<24 | uint32(b[5])<<16 | uint32(b [6])<<8 | uint32(b[7]), | |
| 189 AreaID: uint32(b[8])<<24 | uint32(b[9])<<16 | uint32(b [10])<<8 | uint32(b[11]), | |
| 190 Checksum: uint16(b[12])<<8 | uint16(b[13]), | |
| 191 } | |
| 192 } | |
| 193 | |
| 194 b := make([]byte, 1500) | |
| 195 for { | |
| 196 iph, p, _, err := r.Read(b) | |
| 197 if err != nil { | |
| 198 log.Fatal(err) | |
| 199 } | |
| 200 if iph.Version != ipv4.Version { | |
| 201 continue | |
| 202 } | |
| 203 if iph.Dst.IsMulticast() { | |
| 204 if !iph.Dst.Equal(AllSPFRouters) && !iph.Dst.Equal(AllDe signatedRouters) { | |
| 205 continue | |
| 206 } | |
| 207 } | |
| 208 ospfh := parseOSPFHeader(p) | |
| 209 if ospfh == nil { | |
| 210 continue | |
| 211 } | |
| 212 if ospfh.Version != OSPF_VERSION { | |
| 213 continue | |
| 214 } | |
| 215 switch ospfh.Type { | |
| 216 case OSPF_TYPE_HELLO: | |
| 217 case OSPF_TYPE_DB_DESCRIPTION: | |
| 218 case OSPF_TYPE_LS_REQUEST: | |
| 219 case OSPF_TYPE_LS_UPDATE: | |
| 220 case OSPF_TYPE_LS_ACK: | |
| 221 } | |
| 222 } | |
| 223 } | |
| 224 | |
| 225 func ExampleWriteOSPFHello(c *ipv4.RawConn, ifs []*net.Interface) { | |
| 226 hello := make([]byte, OSPFHelloHeaderLen) | |
| 227 | |
| 228 ospf := make([]byte, OSPFHeaderLen) | |
| 229 ospf[0] = OSPF_VERSION | |
| 230 ospf[1] = OSPF_TYPE_HELLO | |
| 231 ospf = append(ospf, hello...) | |
| 232 | |
| 233 iph := &ipv4.Header{} | |
| 234 iph.Len = ipv4.HeaderLen | |
| 235 iph.TOS = ipv4.DSCP_CS6 | |
| 236 iph.TotalLen = ipv4.HeaderLen + len(ospf) | |
| 237 iph.TTL = 1 | |
| 238 iph.Protocol = 89 | |
| 239 iph.Dst = AllSPFRouters | |
| 240 | |
| 241 for _, ifi := range ifs { | |
| 242 err := c.SetMulticastInterface(ifi) | |
| 243 if err != nil { | |
| 244 return | |
| 245 } | |
| 246 err = c.Write(iph, ospf, nil) | |
| 247 if err != nil { | |
| 248 return | |
| 249 } | |
| 250 } | |
| 251 } | |
| OLD | NEW |
