Merge pull request #12 from jerome-laforge/master

Add more helper functions for RelayMessageOption.

miscoptions.go

@@ -294,3 +294,27 @@ func (r *RelayMessageOption) SetRelayMessage(p *RelayMessage) error {
 	*r = b
 	return nil
 }
+
+// ClientServerMessage gets the client server message (e.g. Solicit,
+// Advertise ...) into this option (when hopcount = 0 of outer RelayMessage).
+func (r *RelayMessageOption) ClientServerMessage() (*Packet, error) {
+	p := new(Packet)
+	err := p.UnmarshalBinary(*r)
+	if err != nil {
+		return nil, err
+	}
+
+	return p, nil
+}
+
+// RelayMessage gets the relay message (e.g. Relay Forward, Relay Reply) into
+// this option (when hopcount > 0 of outer RelayMessage).
+func (r *RelayMessageOption) RelayMessage() (*RelayMessage, error) {
+	rm := new(RelayMessage)
+	err := rm.UnmarshalBinary(*r)
+	if err != nil {
+		return nil, err
+	}
+
+	return rm, nil
+}

options.go

@@ -274,6 +274,26 @@ func (o Options) ElapsedTime() (ElapsedTime, bool, error) {
 	return *t, true, err
 }
 
+// RelayMessageOption returns the Relay Message Option value, as described in RFC 3315,
+// Section 22.10.
+//
+// The RelayMessage option carries a DHCP message in a Relay-forward or
+// Relay-reply message.
+//
+// The boolean return value indicates if OptionRelayMsg was present in the
+// Options map.  The error return value indicates if a valid OptionRelayMsg could be
+// parsed from the option.
+func (o Options) RelayMessageOption() (RelayMessageOption, bool, error) {
+	v, ok := o.Get(OptionRelayMsg)
+	if !ok {
+		return nil, false, nil
+	}
+
+	r := new(RelayMessageOption)
+	err := r.UnmarshalBinary(v)
+	return *r, true, err
+}
+
 // Authentication returns the Authentication Option value, as described in RFC 3315,
 // Section 22.11.
 //

options_test.go

@@ -1136,6 +1136,49 @@ func TestOptionsElapsedTime(t *testing.T) {
 	}
 }
 
+// TestOptionsRelayMessage verifies that Options.RelayMessageOption properly parses and
+// returns an relay message option value, if one is available with RelayMessageOption.
+func TestOptionsRelayMessage(t *testing.T) {
+	var tests = []struct {
+		desc           string
+		options        Options
+		authentication RelayMessageOption
+		ok             bool
+		err            error
+	}{
+		{
+			desc: "RelayMessageOption not present in Options map",
+		},
+		{
+			desc: "RelayMessageOption present in Options map",
+			options: Options{
+				OptionRelayMsg: [][]byte{{1, 1, 2, 3}},
+			},
+			authentication: []byte{1, 1, 2, 3},
+			ok:             true,
+		},
+	}
+
+	for i, tt := range tests {
+		relayMsg, ok, err := tt.options.RelayMessageOption()
+		if want, got := tt.err, err; want != got {
+			t.Fatalf("[%02d] test %q, unexpected error for Options.RelayMessageOption\n- want: %v\n-  got: %v", i, tt.desc, want, got)
+		}
+
+		if tt.err != nil {
+			continue
+		}
+
+		if want, got := tt.authentication, relayMsg; !reflect.DeepEqual(want, got) {
+			t.Fatalf("[%02d] test %q, unexpected value for Options.RelayMessageOption()\n- want: %v\n-  got: %v", i, tt.desc, want, got)
+		}
+
+		if want, got := tt.ok, ok; want != got {
+			t.Fatalf("[%02d] test %q, unexpected ok for Options.RelayMessageOption(): %v != %v", i, tt.desc, want, got)
+		}
+	}
+}
+
 // TestAuthentication verifies that Options.Authentication properly parses and
 // returns an authentication value, if one is available with Authentication.
 func TestAuthentication(t *testing.T) {