From 89df4777a1687cf4d796afc91b30fa0beee7506d Mon Sep 17 00:00:00 2001 From: Andrea Barberio Date: Mon, 28 Jan 2019 10:47:25 +0000 Subject: Created examples directory and adjusted README --- examples/client6/README.md | 5 +++ examples/client6/main.go | 42 ++++++++++++++++++++++ examples/packetcrafting6/README.md | 26 ++++++++++++++ examples/packetcrafting6/main.go | 72 +++++++++++++++++++++++++++++++++++++ examples/server6/README.md | 10 ++++++ examples/server6/main.go | 27 ++++++++++++++ examples/server6/server6 | Bin 0 -> 2842321 bytes 7 files changed, 182 insertions(+) create mode 100644 examples/client6/README.md create mode 100644 examples/client6/main.go create mode 100644 examples/packetcrafting6/README.md create mode 100644 examples/packetcrafting6/main.go create mode 100644 examples/server6/README.md create mode 100644 examples/server6/main.go create mode 100755 examples/server6/server6 (limited to 'examples') diff --git a/examples/client6/README.md b/examples/client6/README.md new file mode 100644 index 0000000..5fa7bfa --- /dev/null +++ b/examples/client6/README.md @@ -0,0 +1,5 @@ +# DHCPv6 client + +A minimal DHCPv6 client can be implemented in a few lines of code, by using the default +client parameters. The example in [main.go](./main.go) lets you specify the +interface to send packets through, and defaults to `eth0`. diff --git a/examples/client6/main.go b/examples/client6/main.go new file mode 100644 index 0000000..41cf692 --- /dev/null +++ b/examples/client6/main.go @@ -0,0 +1,42 @@ +package main + +import ( + "flag" + "log" + + "github.com/insomniacslk/dhcp/dhcpv6/client6" +) + +var ( + iface = flag.String("i", "eth0", "Interface to configure via DHCPv6") +) + +func main() { + flag.Parse() + log.Printf("Starting DHCPv6 client on interface %s", *iface) + + // NewClient sets up a new DHCPv6 client with default values + // for read and write timeouts, for destination address and listening + // address + client := client6.NewClient() + + // Exchange runs a Solicit-Advertise-Request-Reply transaction on the + // specified network interface, and returns a list of DHCPv6 packets + // (a "conversation") and an error if any. Notice that Exchange may + // return a non-empty packet list even if there is an error. This is + // intended, because the transaction may fail at any point, and we + // still want to know what packets were exchanged until then. + // A default Solicit packet will be used during the "conversation", + // which can be manipulated by using modifiers. + conversation, err := client.Exchange(*iface) + + // Summary() prints a verbose representation of the exchanged packets. + for _, packet := range conversation { + log.Print(packet.Summary()) + } + // error handling is done *after* printing, so we still print the + // exchanged packets if any, as explained above. + if err != nil { + log.Fatal(err) + } +} diff --git a/examples/packetcrafting6/README.md b/examples/packetcrafting6/README.md new file mode 100644 index 0000000..cf1a370 --- /dev/null +++ b/examples/packetcrafting6/README.md @@ -0,0 +1,26 @@ +# DHCPv6 packet crafting + +It is easy to parse, create and manipulate DHCPv6 packets. The `DHCPv6` +interface is the central way to move packets around. Two concrete +implementations, `DHCPv6Message` and `DHCPv6Relay` take care of the +details. The example in [main.go](./main.go) shows how to craft a DHCP6 +Solicit message with a custom DUID_LLT, encapsulate it in a Relay message, +and print its details. + + +The output (slightly modified for readability) is +``` +$ go run main.go +2018/11/08 13:56:31 DHCPv6Relay + messageType=RELAY-FORW + hopcount=0 + linkaddr=2001:db8::1 + peeraddr=2001:db8::2 + options=[OptRelayMsg{relaymsg=DHCPv6Message(messageType=SOLICIT transactionID=0x9e0242, 4 options)}] + +2018/11/08 13:56:31 [12 0 32 1 13 184 0 0 0 0 0 0 0 0 0 0 0 1 32 1 13 184 + 0 0 0 0 0 0 0 0 0 0 0 2 0 9 0 52 1 158 2 66 0 1 0 14 + 0 1 0 1 35 118 253 15 0 250 206 176 12 0 0 6 0 4 0 23 + 0 24 0 8 0 2 0 0 0 3 0 12 250 206 176 12 0 0 14 16 0 + 0 21 24] +``` diff --git a/examples/packetcrafting6/main.go b/examples/packetcrafting6/main.go new file mode 100644 index 0000000..afba3a0 --- /dev/null +++ b/examples/packetcrafting6/main.go @@ -0,0 +1,72 @@ +package main + +import ( + "log" + "net" + + "github.com/insomniacslk/dhcp/dhcpv6" + "github.com/insomniacslk/dhcp/iana" +) + +func main() { + // In this example we create and manipulate a DHCPv6 solicit packet + // and encapsulate it in a relay packet. To to this, we use + // `dhcpv6.DHCPv6Message` and `dhcpv6.DHCPv6Relay`, two structures + // that implement the `dhcpv6.DHCPv6` interface. + // Then print the wire-format representation of the packet. + + // Create the DHCPv6 Solicit first, using the interface "eth0" + // to get the MAC address + msg, err := dhcpv6.NewSolicitForInterface("eth0") + if err != nil { + log.Fatal(err) + } + + // In this example I want to redact the MAC address of my + // network interface, so instead of replacing it manually, + // I will show how to use modifiers for the purpose. + // A Modifier is simply a function that can be applied on + // a DHCPv6 object to manipulate it. Here we use it to + // replace the MAC address with a dummy one. + // Modifiers can be passed to many functions, for example + // to constructors, `Exchange()`, `Solicit()`, etc. Check + // the source code to know where to use them. + // Existing modifiers are implemented in dhcpv6/modifiers.go . + mac, err := net.ParseMAC("00:fa:ce:b0:0c:00") + if err != nil { + log.Fatal(err) + } + duid := dhcpv6.Duid{ + Type: dhcpv6.DUID_LLT, + HwType: iana.HWTypeEthernet, + Time: dhcpv6.GetTime(), + LinkLayerAddr: mac, + } + // As suggested above, an alternative is to call + // dhcpv6.NewSolicitForInterface("eth0", dhcpv6.WithCLientID(duid)) + msg = dhcpv6.WithClientID(duid)(msg) + + // Now encapsulate the message in a DHCPv6 relay. + // As per RFC3315, the link-address and peer-address have + // to be set by the relay agent. We use dummy values here. + linkAddr := net.ParseIP("2001:0db8::1") + peerAddr := net.ParseIP("2001:0db8::2") + relay, err := dhcpv6.EncapsulateRelay(msg, dhcpv6.MessageTypeRelayForward, linkAddr, peerAddr) + if err != nil { + log.Fatal(err) + } + + // Print a verbose representation of the relay packet, that will also + // show a short representation of the inner Solicit message. + // To print a detailed summary of the inner packet, extract it + // first from the relay using `relay.GetInnerMessage()`. + log.Print(relay.Summary()) + + // And finally, print the bytes that would be sent on the wire + log.Print(relay.ToBytes()) + + // Note: there are many more functions in the library, check them + // out in the source code. For example, if you want to decode a + // byte stream into a DHCPv6 message or relay, you can use + // `dhcpv6.FromBytes`. +} diff --git a/examples/server6/README.md b/examples/server6/README.md new file mode 100644 index 0000000..490fa72 --- /dev/null +++ b/examples/server6/README.md @@ -0,0 +1,10 @@ +# DHCPv6 server + +A DHCPv6 server requires the user to implement a request handler. Basically the +user has to provide the logic to answer to each packet. The library offers a few +facilities to forge response packets, e.g. `NewAdvertiseFromSolicit`, +`NewReplyFromDHCPv6Message` and so on. Look at the source code to see what's +available. + +An example server that will print (but not reply to) the client's request is +shown in [main.go](./main.go) diff --git a/examples/server6/main.go b/examples/server6/main.go new file mode 100644 index 0000000..174f798 --- /dev/null +++ b/examples/server6/main.go @@ -0,0 +1,27 @@ +package main + +import ( + "log" + "net" + + "github.com/insomniacslk/dhcp/dhcpv6" + "github.com/insomniacslk/dhcp/dhcpv6/server6" +) + +func handler(conn net.PacketConn, peer net.Addr, m dhcpv6.DHCPv6) { + // this function will just print the received DHCPv6 message, without replying + log.Print(m.Summary()) +} + +func main() { + laddr := net.UDPAddr{ + IP: net.ParseIP("::1"), + Port: dhcpv6.DefaultServerPort, + } + server := server6.NewServer(laddr, handler) + + defer server.Close() + if err := server.ActivateAndServe(); err != nil { + log.Panic(err) + } +} diff --git a/examples/server6/server6 b/examples/server6/server6 new file mode 100755 index 0000000..16f6153 Binary files /dev/null and b/examples/server6/server6 differ -- cgit v1.2.3