Added support for nics.*.allow_restricted_traffic, .allow_ip_spoofing…

…, .allow_mac_spoofing.

machine.go

@@ -196,9 +196,11 @@ func stringsAreEqual(a interface{}, b interface{}) bool {
 type NetworkInterface struct {
 	/*
 		AllowDHCPSpoofing     bool     `json:"allow_dhcp_spoofing,omitempty"`
-		AllowIPSpoofing       bool     `json:"allow_ip_spoofing,omitempty"`
-		AllowMACSpoofing      bool     `json:"allow_mac_spoofing,omitempty"`
-		AllowRestrictedTrafic bool     `json:"allow_restricted_traffic,omitempty"`
+	*/
+	AllowIPSpoofing        bool `json:"allow_ip_spoofing"`
+	AllowMACSpoofing       bool `json:"allow_mac_spoofing"`
+	AllowRestrictedTraffic bool `json:"allow_restricted_traffic"`
+	/*
 		BlockedOutgoingPorts  []uint16 `json:"blocked_outgoing_ports,omitempty"`
 	*/
 	Gateways    []string `json:"gateways,omitempty"`
@@ -222,6 +224,21 @@ func getNetworkInterfaces(d interface{}) ([]NetworkInterface, error) {
 	for _, nid := range networkInterfaceDefinitions {
 		networkInterfaceDefinition := nid.(map[string]interface{})
 
+		allowRestrictedTraffic := false
+		if value, ok := networkInterfaceDefinition["allow_restricted_traffic"].(bool); ok {
+			allowRestrictedTraffic = value
+		}
+
+		allowIPSpoofing := false
+		if value, ok := networkInterfaceDefinition["allow_ip_spoofing"].(bool); ok {
+			allowIPSpoofing = value
+		}
+
+		allowMACSpoofing := false
+		if value, ok := networkInterfaceDefinition["allow_mac_spoofing"].(bool); ok {
+			allowMACSpoofing = value
+		}
+
 		var gateways []string
 		for _, gateway := range networkInterfaceDefinition["gateways"].([]interface{}) {
 			gateways = append(gateways, gateway.(string))
@@ -247,12 +264,15 @@ func getNetworkInterfaces(d interface{}) ([]NetworkInterface, error) {
 		}
 
 		networkInterface := NetworkInterface{
-			Interface:    interfaceName,
-			IPAddresses:  ips,
-			Tag:          nicTag,
-			Gateways:     gateways,
-			VirtualLANID: vlanID,
-			Model:        model,
+			AllowRestrictedTraffic: allowRestrictedTraffic,
+			AllowIPSpoofing:        allowIPSpoofing,
+			AllowMACSpoofing:       allowMACSpoofing,
+			Interface:              interfaceName,
+			IPAddresses:            ips,
+			Tag:                    nicTag,
+			Gateways:               gateways,
+			VirtualLANID:           vlanID,
+			Model:                  model,
 		}
 
 		networkInterfaces = append(networkInterfaces, networkInterface)

resource_machine.go

@@ -228,6 +228,21 @@ func resourceMachine() *schema.Resource {
 				ForceNew: true,
 				Elem: &schema.Resource{
 					Schema: map[string]*schema.Schema{
+						"allow_restricted_traffic": &schema.Schema{
+							Type:     schema.TypeBool,
+							Optional: true,
+							ForceNew: true,
+						},
+						"allow_ip_spoofing": &schema.Schema{
+							Type:     schema.TypeBool,
+							Optional: true,
+							ForceNew: true,
+						},
+						"allow_mac_spoofing": &schema.Schema{
+							Type:     schema.TypeBool,
+							Optional: true,
+							ForceNew: true,
+						},
 						"gateways": &schema.Schema{
 							Type:     schema.TypeList,
 							Optional: true,
@@ -518,6 +533,17 @@ func resourceMachineUpdate(d *schema.ResourceData, m interface{}) error {
 		updatesRequired = true
 	}
 
+	if d.HasChange("nics") && !d.IsNewResource() {
+		_, newSchemaValue := d.GetChange("nics")
+
+		var nics []NetworkInterface
+		for _, nic := range newSchemaValue.([]interface{}) {
+			nics = append(nics, nic.(NetworkInterface))
+		}
+		machineUpdate.NetworkInterfaces = nics
+		updatesRequired = true
+	}
+
 	if updatesRequired {
 		client := m.(*SmartOSClient)