init/updateFortiOSTerraform: 1.24.0

Signed-off-by: FTNT-HQCM <hq-devops-admin@fortinet.com>

Author: FTNT-HQCM

CHANGELOG.md

@@ -1,6 +1,29 @@
-## 1.24.0 (Unreleased)
+## 1.25.0 (Unreleased)
 
 
+## 1.24.0 (Jan 14, 2026)
+BUG FIXES:
+
+* Fix mac address upper case issue; 
+* Fix extra quote issue;
+* Fix nil pointer issue;
+* Ignore add empty value for variables that could affect other arguments;
+* Fix false required variables of resource firewall_centralsnatmap;
+* Fix issue of tcp_portrange could not be set of resource firewallservice_custom;
+* Fix table order mismatch issue;
+
+IMPROVEMENTS:
+
+* Support FortiOS version  7.6.5;
+* Support unset operation for complex variables;
+* Support unset operation for variable options of resource webfilter_profile;
+* Add validation function to validate subnet;
+
+FEATURES:
+
+* **New Resource:** `fortios_system_sovsase`
+* **New Resource:** `fortios_wirelesscontroller_lwprofile`
+
 ## 1.23.0 (Oct 02, 2025)
 BUG FIXES:
 

fortios/config.go

@@ -378,3 +378,81 @@ func remove_quote(v interface{}) interface{} {
 func bZero(v interface{}) bool {
 	return reflect.ValueOf(v).IsZero()
 }
+
+func mergeBlock(tf_list, rsp_list []interface{}, tf_mkey, api_mkey string) []interface{} {
+	result := []interface{}{}
+	mkey_index_map := make(map[string]int)
+
+	// create mkey to index map
+	for i, raw := range rsp_list {
+		if raw == nil {
+			continue
+		}
+		item := raw.(map[string]interface{})
+
+		keyStr := fmt.Sprintf("%v", item[api_mkey])
+		mkey_index_map[keyStr] = i
+	}
+
+	// parse item in terraform configuration
+	zeroCount := 0
+	for _, raw := range tf_list {
+		if raw == nil {
+			continue
+		}
+		item := raw.(map[string]interface{})
+
+		keyStr := fmt.Sprintf("%v", item[tf_mkey])
+
+		if rspIndex, ok := mkey_index_map[keyStr]; ok {
+			rspItem := rsp_list[rspIndex].(map[string]interface{})
+			rspItem["tf_exist"] = true
+			result = append(result, rspItem)
+
+			delete(mkey_index_map, keyStr)
+		} else {
+			if keyStr == "0" {
+				zeroCount += 1
+				continue
+			}
+			emptyMap := map[string]interface{}{
+				"tf_exist": true,
+			}
+			result = append(result, emptyMap)
+		}
+	}
+
+	// add items only in response
+	for _, idx := range mkey_index_map {
+		v := rsp_list[idx].(map[string]interface{})
+		if zeroCount > 0 {
+			v["tf_exist"] = true
+			zeroCount -= 1
+		} else {
+			v["tf_exist"] = false
+		}
+		result = append(result, v)
+	}
+
+	return result
+}
+
+func isValidSubnet(i interface{}, k string) (warnings []string, errors []error) {
+	value := i.(string)
+	cidrValue := convertIP(value)
+	ip, ipNet, err := net.ParseCIDR(cidrValue)
+	if err != nil {
+		errors = append(errors, fmt.Errorf(
+			"Variable %q is not a valid subnet: %v", k, value,
+		))
+		return
+	}
+	// Check if IP equals the network base address
+	if !ip.Equal(ipNet.IP) {
+		warnings = append(warnings, fmt.Sprintf(
+			"Variable %q is not a valid subnet: %v, do you mean %v?", k, value, ipNet,
+		))
+		return
+	}
+	return
+}

fortios/data_source_firewall_address.go

@@ -268,6 +268,10 @@ func dataSourceFirewallAddress() *schema.Resource {
 				Type:     schema.TypeString,
 				Computed: true,
 			},
+			"passive_fqdn_learning": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
 			"fabric_object": &schema.Schema{
 				Type:     schema.TypeString,
 				Computed: true,
@@ -727,6 +731,10 @@ func dataSourceFlattenFirewallAddressAllowRouting(v interface{}, d *schema.Resou
 	return v
 }
 
+func dataSourceFlattenFirewallAddressPassiveFqdnLearning(v interface{}, d *schema.ResourceData, pre string) interface{} {
+	return v
+}
+
 func dataSourceFlattenFirewallAddressFabricObject(v interface{}, d *schema.ResourceData, pre string) interface{} {
 	return v
 }
@@ -1010,6 +1018,12 @@ func dataSourceRefreshObjectFirewallAddress(d *schema.ResourceData, o map[string
 		}
 	}
 
+	if err = d.Set("passive_fqdn_learning", dataSourceFlattenFirewallAddressPassiveFqdnLearning(o["passive-fqdn-learning"], d, "passive_fqdn_learning")); err != nil {
+		if !fortiAPIPatch(o["passive-fqdn-learning"]) {
+			return fmt.Errorf("Error reading passive_fqdn_learning: %v", err)
+		}
+	}
+
 	if err = d.Set("fabric_object", dataSourceFlattenFirewallAddressFabricObject(o["fabric-object"], d, "fabric_object")); err != nil {
 		if !fortiAPIPatch(o["fabric-object"]) {
 			return fmt.Errorf("Error reading fabric_object: %v", err)

fortios/data_source_firewall_address6.go

@@ -204,6 +204,10 @@ func dataSourceFirewallAddress6() *schema.Resource {
 				Type:     schema.TypeString,
 				Computed: true,
 			},
+			"passive_fqdn_learning": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
 			"fabric_object": &schema.Schema{
 				Type:     schema.TypeString,
 				Computed: true,
@@ -571,6 +575,10 @@ func dataSourceFlattenFirewallAddress6SdnAddrType(v interface{}, d *schema.Resou
 	return v
 }
 
+func dataSourceFlattenFirewallAddress6PassiveFqdnLearning(v interface{}, d *schema.ResourceData, pre string) interface{} {
+	return v
+}
+
 func dataSourceFlattenFirewallAddress6FabricObject(v interface{}, d *schema.ResourceData, pre string) interface{} {
 	return v
 }
@@ -758,6 +766,12 @@ func dataSourceRefreshObjectFirewallAddress6(d *schema.ResourceData, o map[strin
 		}
 	}
 
+	if err = d.Set("passive_fqdn_learning", dataSourceFlattenFirewallAddress6PassiveFqdnLearning(o["passive-fqdn-learning"], d, "passive_fqdn_learning")); err != nil {
+		if !fortiAPIPatch(o["passive-fqdn-learning"]) {
+			return fmt.Errorf("Error reading passive_fqdn_learning: %v", err)
+		}
+	}
+
 	if err = d.Set("fabric_object", dataSourceFlattenFirewallAddress6FabricObject(o["fabric-object"], d, "fabric_object")); err != nil {
 		if !fortiAPIPatch(o["fabric-object"]) {
 			return fmt.Errorf("Error reading fabric_object: %v", err)

fortios/data_source_firewall_proxypolicy.go

@@ -128,6 +128,18 @@ func dataSourceFirewallProxyPolicy() *schema.Resource {
 					},
 				},
 			},
+			"poolname6": &schema.Schema{
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"name": &schema.Schema{
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
 			"dstaddr": &schema.Schema{
 				Type:     schema.TypeList,
 				Computed: true,
@@ -919,6 +931,42 @@ func dataSourceFlattenFirewallProxyPolicyPoolnameName(v interface{}, d *schema.R
 	return v
 }
 
+func dataSourceFlattenFirewallProxyPolicyPoolname6(v interface{}, d *schema.ResourceData, pre string) []map[string]interface{} {
+	if v == nil {
+		return nil
+	}
+
+	l := v.([]interface{})
+	if len(l) == 0 || l[0] == nil {
+		return nil
+	}
+
+	result := make([]map[string]interface{}, 0, len(l))
+
+	con := 0
+	for _, r := range l {
+		tmp := make(map[string]interface{})
+		i := r.(map[string]interface{})
+
+		pre_append := "" // table
+
+		pre_append = pre + "." + strconv.Itoa(con) + "." + "name"
+		if _, ok := i["name"]; ok {
+			tmp["name"] = dataSourceFlattenFirewallProxyPolicyPoolname6Name(i["name"], d, pre_append)
+		}
+
+		result = append(result, tmp)
+
+		con += 1
+	}
+
+	return result
+}
+
+func dataSourceFlattenFirewallProxyPolicyPoolname6Name(v interface{}, d *schema.ResourceData, pre string) interface{} {
+	return v
+}
+
 func dataSourceFlattenFirewallProxyPolicyDstaddr(v interface{}, d *schema.ResourceData, pre string) []map[string]interface{} {
 	if v == nil {
 		return nil
@@ -1920,6 +1968,12 @@ func dataSourceRefreshObjectFirewallProxyPolicy(d *schema.ResourceData, o map[st
 		}
 	}
 
+	if err = d.Set("poolname6", dataSourceFlattenFirewallProxyPolicyPoolname6(o["poolname6"], d, "poolname6")); err != nil {
+		if !fortiAPIPatch(o["poolname6"]) {
+			return fmt.Errorf("Error reading poolname6: %v", err)
+		}
+	}
+
 	if err = d.Set("dstaddr", dataSourceFlattenFirewallProxyPolicyDstaddr(o["dstaddr"], d, "dstaddr")); err != nil {
 		if !fortiAPIPatch(o["dstaddr"]) {
 			return fmt.Errorf("Error reading dstaddr: %v", err)

fortios/data_source_firewallschedule_recurring.go

@@ -48,6 +48,10 @@ func dataSourceFirewallScheduleRecurring() *schema.Resource {
 				Type:     schema.TypeString,
 				Computed: true,
 			},
+			"label_day": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
 			"color": &schema.Schema{
 				Type:     schema.TypeInt,
 				Computed: true,
@@ -123,6 +127,10 @@ func dataSourceFlattenFirewallScheduleRecurringDay(v interface{}, d *schema.Reso
 	return v
 }
 
+func dataSourceFlattenFirewallScheduleRecurringLabelDay(v interface{}, d *schema.ResourceData, pre string) interface{} {
+	return v
+}
+
 func dataSourceFlattenFirewallScheduleRecurringColor(v interface{}, d *schema.ResourceData, pre string) interface{} {
 	return v
 }
@@ -164,6 +172,12 @@ func dataSourceRefreshObjectFirewallScheduleRecurring(d *schema.ResourceData, o
 		}
 	}
 
+	if err = d.Set("label_day", dataSourceFlattenFirewallScheduleRecurringLabelDay(o["label-day"], d, "label_day")); err != nil {
+		if !fortiAPIPatch(o["label-day"]) {
+			return fmt.Errorf("Error reading label_day: %v", err)
+		}
+	}
+
 	if err = d.Set("color", dataSourceFlattenFirewallScheduleRecurringColor(o["color"], d, "color")); err != nil {
 		if !fortiAPIPatch(o["color"]) {
 			return fmt.Errorf("Error reading color: %v", err)

fortios/data_source_router_routemap.go

@@ -109,6 +109,10 @@ func dataSourceRouterRouteMap() *schema.Resource {
 							Type:     schema.TypeInt,
 							Computed: true,
 						},
+						"match_suppress": &schema.Schema{
+							Type:     schema.TypeString,
+							Computed: true,
+						},
 						"set_aggregator_as": &schema.Schema{
 							Type:     schema.TypeInt,
 							Computed: true,
@@ -435,6 +439,11 @@ func dataSourceFlattenRouterRouteMapRule(v interface{}, d *schema.ResourceData,
 			tmp["match_vrf"] = dataSourceFlattenRouterRouteMapRuleMatchVrf(i["match-vrf"], d, pre_append)
 		}
 
+		pre_append = pre + "." + strconv.Itoa(con) + "." + "match_suppress"
+		if _, ok := i["match-suppress"]; ok {
+			tmp["match_suppress"] = dataSourceFlattenRouterRouteMapRuleMatchSuppress(i["match-suppress"], d, pre_append)
+		}
+
 		pre_append = pre + "." + strconv.Itoa(con) + "." + "set_aggregator_as"
 		if _, ok := i["set-aggregator-as"]; ok {
 			tmp["set_aggregator_as"] = dataSourceFlattenRouterRouteMapRuleSetAggregatorAs(i["set-aggregator-as"], d, pre_append)
@@ -676,6 +685,10 @@ func dataSourceFlattenRouterRouteMapRuleMatchVrf(v interface{}, d *schema.Resour
 	return v
 }
 
+func dataSourceFlattenRouterRouteMapRuleMatchSuppress(v interface{}, d *schema.ResourceData, pre string) interface{} {
+	return v
+}
+
 func dataSourceFlattenRouterRouteMapRuleSetAggregatorAs(v interface{}, d *schema.ResourceData, pre string) interface{} {
 	return v
 }