Refactoring

- Use layers.DHCPOpt instead of byte
- Add AddOption and AddParamRequest
- Add request flag to command

Author: corny

client.go

@@ -36,12 +36,6 @@ type Client struct {
 	wg       sync.WaitGroup // For graceful shutdown
 }
 
-// Option is a DHCP option field
-type Option struct {
-	Type layers.DHCPOpt
-	Data []byte
-}
-
 // Lease is an assignment by the DHCP server
 type Lease struct {
 	ServerID     net.IP
@@ -62,23 +56,46 @@ type Lease struct {
 }
 
 // DefaultParamsRequestList is a list of params to be requested from the server
-var DefaultParamsRequestList = []byte{
-	1,  // Subnet Mask
-	3,  // Router
-	4,  // Time Server
-	6,  // Domain Name Server
-	15, // Domain Name
-	26, // Interface MTU
-	42, // Network Time Protocol Servers
+var DefaultParamsRequestList = []layers.DHCPOpt{
+	layers.DHCPOptSubnetMask,   // Subnet Mask
+	layers.DHCPOptRouter,       // Router
+	layers.DHCPOptTimeServer,   // Time Server
+	layers.DHCPOptDNS,          // Domain Name Server
+	layers.DHCPOptDomainName,   // Domain Name
+	layers.DHCPOptInterfaceMTU, // Interface MTU
+	layers.DHCPOptNTPServers,   // Network Time Protocol Servers
+}
+
+// AddOption adds an DHCP option
+func (client *Client) AddOption(optType layers.DHCPOpt, data []byte) {
+	client.DHCPOptions = append(client.DHCPOptions, Option{optType, data})
+}
+
+// AddParamRequest adds an parameter to parameter request list, if not included yet.
+func (client *Client) AddParamRequest(dhcpOpt layers.DHCPOpt) {
+
+	// search for existing parameter request list
+	for i := range client.DHCPOptions {
+		if client.DHCPOptions[i].Type == layers.DHCPOptParamsRequest {
+			// extend existing list
+			client.DHCPOptions[i].AddByte(byte(dhcpOpt))
+			return
+		}
+	}
+
+	// option not added yet
+	client.AddOption(layers.DHCPOptParamsRequest, []byte{byte(dhcpOpt)})
 }
 
 // Start starts the client
 func (client *Client) Start() {
-	if len(client.DHCPOptions) == 0 {
-		client.DHCPOptions = []Option{
-			{layers.DHCPOptHostname, []byte(client.Hostname)},
-			{layers.DHCPOptParamsRequest, DefaultParamsRequestList},
+
+	// Add default DHCP options if none added yet.
+	if client.DHCPOptions == nil {
+		for _, param := range DefaultParamsRequestList {
+			client.AddParamRequest(param)
 		}
+		client.AddOption(layers.DHCPOptHostname, []byte(client.Hostname))
 	}
 
 	if client.notify != nil {

client_test.go

@@ -0,0 +1,32 @@
+package dhclient
+
+import (
+	"testing"
+
+	"github.com/google/gopacket/layers"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAddParamRequest(t *testing.T) {
+	assert := assert.New(t)
+	client := Client{}
+	assert.Len(client.DHCPOptions, 0)
+
+	// Add one option
+	client.AddOption(layers.DHCPOptHostname, []byte("example.com"))
+	assert.Len(client.DHCPOptions, 1)
+
+	// Add first param request
+	client.AddParamRequest(layers.DHCPOptSubnetMask)
+	assert.Len(client.DHCPOptions, 2)
+	assert.Len(client.DHCPOptions[1].Data, 1)
+
+	// Add second param request
+	client.AddParamRequest(layers.DHCPOptRouter)
+	assert.Len(client.DHCPOptions[1].Data, 2)
+
+	// Add existing param request
+	client.AddParamRequest(layers.DHCPOptRouter)
+	assert.Len(client.DHCPOptions[1].Data, 2)
+
+}

cmd/dhclient/byte_list.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+)
+
+type byteList []byte
+
+func (list *byteList) Set(value string) error {
+	u, err := strconv.ParseUint(value, 0, 8)
+	if err != nil {
+		return err
+	}
+
+	*list = append(*list, byte(u))
+	return nil
+}
+
+func (list *byteList) String() string {
+	out := new(bytes.Buffer)
+	for _, b := range *list {
+		if out.Len() != 0 {
+			out.WriteByte(' ')
+		}
+		fmt.Fprintf(out, "%d", b)
+	}
+	return out.String()
+}

cmd/dhclient/byte_list_test.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestByteList(t *testing.T) {
+	assert := assert.New(t)
+
+	m := byteList{}
+
+	assert.EqualError(m.Set("foo"), "strconv.ParseUint: parsing \"foo\": invalid syntax")
+
+	assert.NoError(m.Set("65"))
+	assert.NoError(m.Set("0x0f"))
+	assert.Len(m, 2)
+	assert.Equal("65 15", m.String())
+}

cmd/dhclient/main.go

@@ -1,28 +1,30 @@
 package main
 
 import (
-	"encoding/hex"
 	"flag"
 	"fmt"
 	"log"
 	"net"
 	"os"
 	"os/signal"
-	"strings"
 	"syscall"
 
 	"github.com/digineo/go-dhclient"
 	"github.com/google/gopacket/layers"
 )
 
-var options = make(optionMap)
+var (
+	options       = optionList{}
+	requestParams = byteList{}
+)
 
 func init() {
 	flag.Usage = func() {
 		fmt.Printf("syntax: %s [flags] IFNAME\n", os.Args[0])
 		flag.PrintDefaults()
 	}
-	flag.Var(&options, "option", "custom DHCP option (code,value)")
+	flag.Var(&options, "option", "custom DHCP option for the request (code,value)")
+	flag.Var(&requestParams, "request", "Additional value for the DHCP Request List Option 55 (code)")
 }
 
 func main() {
@@ -34,47 +36,40 @@ func main() {
 		os.Exit(1)
 	}
 
-	log.Println(options)
-
-	hostname, _ := os.Hostname()
 	ifname := flag.Arg(0)
-
 	iface, err := net.InterfaceByName(ifname)
 	if err != nil {
 		fmt.Printf("unable to find interface %s: %s\n", ifname, err)
 		os.Exit(1)
 	}
 
-	dhcpOptions := []dhclient.Option{
-		{Type: layers.DHCPOptHostname, Data: []byte(hostname)},
-		{Type: layers.DHCPOptParamsRequest, Data: dhclient.DefaultParamsRequestList},
+	client := dhclient.Client{
+		Iface: iface,
+		OnBound: func(lease *dhclient.Lease) {
+			log.Printf("Bound: %+v", lease)
+		},
 	}
 
-	for k, v := range options {
-		var data []byte
-
-		if strings.HasPrefix(v, "0x") {
-			data, err = hex.DecodeString(v[2:])
-			if err != nil {
-				fmt.Printf("value \"%s\" is invalid: %s\n", v, err)
-				os.Exit(1)
-			}
-		} else {
-			data = []byte(v)
-		}
+	// Add requests for default options
+	for _, param := range dhclient.DefaultParamsRequestList {
+		log.Printf("Requesting default option %d", param)
+		client.AddParamRequest(layers.DHCPOpt(param))
+	}
 
-		dhcpOptions = append(dhcpOptions,
-			dhclient.Option{Type: layers.DHCPOpt(k), Data: data},
-		)
+	// Add requests for custom options
+	for _, param := range requestParams {
+		log.Printf("Requesting custom option %d", param)
+		client.AddParamRequest(layers.DHCPOpt(param))
 	}
 
-	client := dhclient.Client{
-		Iface:    iface,
-		Hostname: hostname,
-		OnBound: func(lease *dhclient.Lease) {
-			log.Printf("Bound: %+v", lease)
-		},
-		DHCPOptions: dhcpOptions,
+	// Add hostname option
+	hostname, _ := os.Hostname()
+	client.AddOption(layers.DHCPOptHostname, []byte(hostname))
+
+	// Add custom options
+	for _, option := range options {
+		log.Printf("Adding option %d=0x%x", option.Type, option.Data)
+		client.AddOption(option.Type, option.Data)
 	}
 
 	client.Start()

cmd/dhclient/option_list.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"bytes"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/google/gopacket/layers"
+
+	dhclient "github.com/digineo/go-dhclient"
+)
+
+type optionList []dhclient.Option
+
+func (m *optionList) Set(arg string) error {
+	i := strings.Index(arg, ",")
+	if i < 0 {
+		return errors.New("invalid \"code,value\" pair")
+	}
+
+	code, err := strconv.Atoi(arg[:i])
+	if err != nil {
+		return fmt.Errorf("option code \"%s\" is invalid", arg[:i])
+	}
+
+	value := arg[i+1:]
+	var data []byte
+	if strings.HasPrefix(value, "0x") {
+		data, err = hex.DecodeString(value[2:])
+		if err != nil {
+			return err
+		}
+	} else {
+		data = []byte(value)
+	}
+
+	*m = append(*m, dhclient.Option{Type: layers.DHCPOpt(code), Data: data})
+	return nil
+}
+
+func (m optionList) String() string {
+	out := new(bytes.Buffer)
+	for _, option := range m {
+		if out.Len() != 0 {
+			out.WriteByte(' ')
+		}
+		fmt.Fprintf(out, "%d,0x%x", option.Type, option.Data)
+	}
+	return out.String()
+}

cmd/dhclient/option_map_test.go cmd/dhclient/option_list_test.go

@@ -6,15 +6,17 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestOptionMap(t *testing.T) {
+func TestOptionList(t *testing.T) {
 	assert := assert.New(t)
 
-	m := make(optionMap)
+	m := optionList{}
 
 	assert.EqualError(m.Set("foo"), "invalid \"code,value\" pair")
 	assert.EqualError(m.Set(","), "option code \"\" is invalid")
 	assert.EqualError(m.Set("0x12,foo"), "option code \"0x12\" is invalid")
 
+	assert.NoError(m.Set("7,0x01020304"))
 	assert.NoError(m.Set("65,foo"))
-	assert.Equal("65,foo", m.String())
+	assert.Len(m, 2)
+	assert.Equal("7,0x01020304 65,0x666f6f", m.String())
 }

cmd/dhclient/option_map.go

@@ -0,0 +1,22 @@
+package dhclient
+
+import (
+	"github.com/google/gopacket/layers"
+)
+
+// Option is a DHCP option field
+type Option struct {
+	Type layers.DHCPOpt
+	Data []byte
+}
+
+// AddByte ensures a specific byte is included in the data
+func (option *Option) AddByte(b byte) {
+	for _, o := range option.Data {
+		if o == b {
+			// already included
+			return
+		}
+	}
+	option.Data = append(option.Data, b)
+}