Netgate TNSR Logo
API docs by Redocly

netgate-vpf API (24.10)

This YANG module provides a Netgate-defined data-model for Netbsd Packet Filters.

Copyright 2024 Rubicon Communications, LLC.

vpf-config

returns netgate.vpf.VpfConfig

VPP Packet Filter (VPF) data needed to support VPP. It consists of a set of named tables containing IP prefixes, a set of named filtering rules, and a set of named NAT rules.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:vpf-config": {
    }
}

creates netgate.vpf.VpfConfig

VPP Packet Filter (VPF) data needed to support VPP. It consists of a set of named tables containing IP prefixes, a set of named filtering rules, and a set of named NAT rules.

Request Body schema: application/yang-data+json

netgate.vpf.VpfConfig to be added to list

object (netgate.vpf.vpfconfig.Options)

VPF interface configuration and enablement options.

object (netgate.vpf.vpfconfig.Ipfix)

IPFIX exporting options.

object (netgate.vpf.vpfconfig.NatRulesets)

A list of VPF NAT rulesets.

object (netgate.vpf.vpfconfig.PrefixTables)

Tables of named IP prefix lists.

object (netgate.vpf.vpfconfig.FilterRulesets)

A list of named VPF filter rulesets.

netgate-vpf:enable
string

If present, the feature is enabled.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:options": {
    },
  • "netgate-vpf:ipfix": {
    },
  • "netgate-vpf:nat-rulesets": {
    },
  • "netgate-vpf:prefix-tables": {
    },
  • "netgate-vpf:filter-rulesets": {
    },
  • "netgate-vpf:enable": "string"
}

creates or updates netgate.vpf.VpfConfig

VPP Packet Filter (VPF) data needed to support VPP. It consists of a set of named tables containing IP prefixes, a set of named filtering rules, and a set of named NAT rules.

Request Body schema: application/yang-data+json

netgate.vpf.VpfConfig to be added or updated

object (netgate.vpf.VpfConfig)

VPP Packet Filter (VPF) data needed to support VPP. It consists of a set of named tables containing IP prefixes, a set of named filtering rules, and a set of named NAT rules.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:vpf-config": {
    }
}

removes netgate.vpf.VpfConfig

VPP Packet Filter (VPF) data needed to support VPP. It consists of a set of named tables containing IP prefixes, a set of named filtering rules, and a set of named NAT rules.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.FilterRulesets

A list of named VPF filter rulesets.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter-rulesets": {
    }
}

creates netgate.vpf.vpfconfig.FilterRulesets

A list of named VPF filter rulesets.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.FilterRulesets to be added to list

Array of objects (netgate.vpf.vpfconfig.filterrulesets.Ruleset)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ruleset": [
    ]
}

creates or updates netgate.vpf.vpfconfig.FilterRulesets

A list of named VPF filter rulesets.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.FilterRulesets to be added or updated

object (netgate.vpf.vpfconfig.FilterRulesets)

A list of named VPF filter rulesets.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter-rulesets": {
    }
}

removes netgate.vpf.vpfconfig.FilterRulesets

A list of named VPF filter rulesets.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

creates netgate.vpf.vpfconfig.filterrulesets.Ruleset

creates netgate.vpf.vpfconfig.filterrulesets.Ruleset

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.filterrulesets.Ruleset to be added to list

netgate-vpf:name
string

The name of the filter ruleset.

netgate-vpf:description
string

A user description of the VPF filter ruleset.

object (netgate.vpf.vpfconfig.filterrulesets.ruleset.Rules)

A list of filter rules within a ruleset ordered by sequence number.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:name": "string",
  • "netgate-vpf:description": "string",
  • "netgate-vpf:rules": {
    }
}

returns netgate.vpf.vpfconfig.filterrulesets.Ruleset

returns netgate.vpf.vpfconfig.filterrulesets.Ruleset

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ruleset": {
    }
}

creates or updates netgate.vpf.vpfconfig.filterrulesets.Ruleset

creates or updates netgate.vpf.vpfconfig.filterrulesets.Ruleset

path Parameters
name
required
string

Id of ruleset

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.filterrulesets.Ruleset to be added or updated

object (netgate.vpf.vpfconfig.filterrulesets.Ruleset)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ruleset": {
    }
}

removes netgate.vpf.vpfconfig.filterrulesets.Ruleset

removes netgate.vpf.vpfconfig.filterrulesets.Ruleset

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.filterrulesets.ruleset.Rules

A list of filter rules within a ruleset ordered by sequence number.

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D/rules"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rules": {
    }
}

creates netgate.vpf.vpfconfig.filterrulesets.ruleset.Rules

A list of filter rules within a ruleset ordered by sequence number.

path Parameters
name
required
string

Id of ruleset

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.filterrulesets.ruleset.Rules to be added to list

Array of objects (netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rule": [
    ]
}

creates or updates netgate.vpf.vpfconfig.filterrulesets.ruleset.Rules

A list of filter rules within a ruleset ordered by sequence number.

path Parameters
name
required
string

Id of ruleset

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.filterrulesets.ruleset.Rules to be added or updated

object (netgate.vpf.vpfconfig.filterrulesets.ruleset.Rules)

A list of filter rules within a ruleset ordered by sequence number.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rules": {
    }
}

removes netgate.vpf.vpfconfig.filterrulesets.ruleset.Rules

A list of filter rules within a ruleset ordered by sequence number.

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D/rules"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

creates netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule

creates netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule

path Parameters
name
required
string

Id of ruleset

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule to be added to list

object (netgate.vpf.VpfMatchConfig)

The packet attributes to match in an VPF rule.

netgate-vpf:sequence
integer <int64>

The VPF filter rule sequence number.

netgate-vpf:return-rst
boolean

Return a TCP reset on match.

netgate-vpf:pass
boolean

If true, the packet is passed, else blocked.

netgate-vpf:return-icmp
boolean

Return an ICMP error on match (Destination Unreachable/Administratively Prohibited).

netgate-vpf:description
string

A user description of the VPF filter rule.

netgate-vpf:tentative
boolean

If this rule is matched, ruleset examination continues and this rule is applied only if there is no other rule to apply. If there is one, then this rule’s match is ignored and the other rule takes preference.

netgate-vpf:ip-version
string (netgate.common.IpAddressFamily)
Enum: "ipv4" "ipv6"
netgate-vpf:stateful
boolean

Create a stateful connection entry upon match.

netgate-vpf:direction
string (netgate.vpf.Direction)
Enum: "in" "out" "both"

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter": {
    },
  • "netgate-vpf:sequence": 0,
  • "netgate-vpf:return-rst": true,
  • "netgate-vpf:pass": true,
  • "netgate-vpf:return-icmp": true,
  • "netgate-vpf:description": "string",
  • "netgate-vpf:tentative": true,
  • "netgate-vpf:ip-version": "ipv4",
  • "netgate-vpf:stateful": true,
  • "netgate-vpf:direction": "in"
}

returns netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule

returns netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rule": {
    }
}

creates or updates netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule

creates or updates netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule to be added or updated

object (netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rule": {
    }
}

removes netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule

removes netgate.vpf.vpfconfig.filterrulesets.ruleset.rules.Rule

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.VpfMatchConfig

returns netgate.vpf.VpfMatchConfig

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/filter"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter": {
    }
}

creates netgate.vpf.VpfMatchConfig

creates netgate.vpf.VpfMatchConfig

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfMatchConfig to be added to list

object (netgate.vpf.VpfMatchConfig)

The packet attributes to match in an VPF rule.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter": {
    }
}

creates or updates netgate.vpf.VpfMatchConfig

creates or updates netgate.vpf.VpfMatchConfig

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfMatchConfig to be added or updated

object (netgate.vpf.VpfMatchConfig)

The packet attributes to match in an VPF rule.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter": {
    }
}

removes netgate.vpf.VpfMatchConfig

removes netgate.vpf.VpfMatchConfig

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/filter"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.VpfEndpoint

The source pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/filter/from"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

creates netgate.vpf.VpfEndpoint

The source pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfEndpoint to be added to list

object (netgate.vpf.VpfEndpoint)

VPF source or destination endpoint

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

creates or updates netgate.vpf.VpfEndpoint

The source pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfEndpoint to be added or updated

object (netgate.vpf.VpfEndpoint)

VPF source or destination endpoint

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

removes netgate.vpf.VpfEndpoint

The source pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/filter/from"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.VpfEndpoint

The destination pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/filter/to"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

creates netgate.vpf.VpfEndpoint

The destination pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfEndpoint to be added to list

object (netgate.vpf.VpfEndpoint)

VPF source or destination endpoint

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

creates or updates netgate.vpf.VpfEndpoint

The destination pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfEndpoint to be added or updated

object (netgate.vpf.VpfEndpoint)

VPF source or destination endpoint

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

removes netgate.vpf.VpfEndpoint

The destination pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/filter/to"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.Ipfix

IPFIX exporting options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/ipfix"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ipfix": {
    }
}

creates netgate.vpf.vpfconfig.Ipfix

IPFIX exporting options.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.Ipfix to be added to list

netgate-vpf:src-port
integer <int32>
Default: 4739

Source port number.

netgate-vpf:enable
string

If present, IPFIX exporting is enabled.

netgate-vpf:domain
integer <int64>
Default: 1

Domain ID.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:src-port": 4739,
  • "netgate-vpf:enable": "string",
  • "netgate-vpf:domain": 1
}

creates or updates netgate.vpf.vpfconfig.Ipfix

IPFIX exporting options.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.Ipfix to be added or updated

object (netgate.vpf.vpfconfig.Ipfix)

IPFIX exporting options.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ipfix": {
    }
}

removes netgate.vpf.vpfconfig.Ipfix

IPFIX exporting options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/ipfix"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.NatRulesets

A list of VPF NAT rulesets.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:nat-rulesets": {
    }
}

creates netgate.vpf.vpfconfig.NatRulesets

A list of VPF NAT rulesets.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.NatRulesets to be added to list

Array of objects (netgate.vpf.vpfconfig.natrulesets.Ruleset)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ruleset": [
    ]
}

creates or updates netgate.vpf.vpfconfig.NatRulesets

A list of VPF NAT rulesets.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.NatRulesets to be added or updated

object (netgate.vpf.vpfconfig.NatRulesets)

A list of VPF NAT rulesets.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:nat-rulesets": {
    }
}

removes netgate.vpf.vpfconfig.NatRulesets

A list of VPF NAT rulesets.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

creates netgate.vpf.vpfconfig.natrulesets.Ruleset

creates netgate.vpf.vpfconfig.natrulesets.Ruleset

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.natrulesets.Ruleset to be added to list

netgate-vpf:name
string

The name of the NAT ruleset.

netgate-vpf:description
string

A user description of the VPF NAT ruleset.

object (netgate.vpf.vpfconfig.natrulesets.ruleset.Rules)

A list of NAT rules within a ruleset ordered by sequence number.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:name": "string",
  • "netgate-vpf:description": "string",
  • "netgate-vpf:rules": {
    }
}

returns netgate.vpf.vpfconfig.natrulesets.Ruleset

returns netgate.vpf.vpfconfig.natrulesets.Ruleset

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ruleset": {
    }
}

creates or updates netgate.vpf.vpfconfig.natrulesets.Ruleset

creates or updates netgate.vpf.vpfconfig.natrulesets.Ruleset

path Parameters
name
required
string

Id of ruleset

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.natrulesets.Ruleset to be added or updated

object (netgate.vpf.vpfconfig.natrulesets.Ruleset)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ruleset": {
    }
}

removes netgate.vpf.vpfconfig.natrulesets.Ruleset

removes netgate.vpf.vpfconfig.natrulesets.Ruleset

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.natrulesets.ruleset.Rules

A list of NAT rules within a ruleset ordered by sequence number.

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rules": {
    }
}

creates netgate.vpf.vpfconfig.natrulesets.ruleset.Rules

A list of NAT rules within a ruleset ordered by sequence number.

path Parameters
name
required
string

Id of ruleset

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.natrulesets.ruleset.Rules to be added to list

Array of objects (netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rule": [
    ]
}

creates or updates netgate.vpf.vpfconfig.natrulesets.ruleset.Rules

A list of NAT rules within a ruleset ordered by sequence number.

path Parameters
name
required
string

Id of ruleset

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.natrulesets.ruleset.Rules to be added or updated

object (netgate.vpf.vpfconfig.natrulesets.ruleset.Rules)

A list of NAT rules within a ruleset ordered by sequence number.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rules": {
    }
}

removes netgate.vpf.vpfconfig.natrulesets.ruleset.Rules

A list of NAT rules within a ruleset ordered by sequence number.

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

creates netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule

creates netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule

path Parameters
name
required
string

Id of ruleset

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule to be added to list

netgate-vpf:sequence
integer <int64>

The VPF NAT rule sequence number.

object (netgate.vpf.vpfconfig.natrulesets.ruleset.rules.rule.Translation)

NAT translation information.

object (netgate.vpf.VpfMatchConfig)

The packet attributes to match in an VPF rule.

netgate-vpf:description
string

A user description of the VPF NAT rule.

netgate-vpf:dynamic
boolean

Dynamic mapping.

netgate-vpf:dest-route-table
string

Name of destination VRF for 'in' NAT rule.

netgate-vpf:no-port-translation
boolean

No port translation.

netgate-vpf:direction
string (netgate.vpf.VpfNatDirection)
Enum: "in" "out"
netgate-vpf:algorithm
string (netgate.vpf.Algorithm)
Enum: "one-to-one" "netmap" "ip-hash" "round-robin" "npt66"

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:sequence": 0,
  • "netgate-vpf:translation": {
    },
  • "netgate-vpf:match": {
    },
  • "netgate-vpf:description": "string",
  • "netgate-vpf:dynamic": true,
  • "netgate-vpf:dest-route-table": "string",
  • "netgate-vpf:no-port-translation": true,
  • "netgate-vpf:direction": "in",
  • "netgate-vpf:algorithm": "one-to-one"
}

returns netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule

returns netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rule": {
    }
}

creates or updates netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule

creates or updates netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule to be added or updated

object (netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rule": {
    }
}

removes netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule

removes netgate.vpf.vpfconfig.natrulesets.ruleset.rules.Rule

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.VpfMatchConfig

returns netgate.vpf.VpfMatchConfig

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/match"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter": {
    }
}

creates netgate.vpf.VpfMatchConfig

creates netgate.vpf.VpfMatchConfig

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfMatchConfig to be added to list

object (netgate.vpf.VpfMatchConfig)

The packet attributes to match in an VPF rule.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter": {
    }
}

creates or updates netgate.vpf.VpfMatchConfig

creates or updates netgate.vpf.VpfMatchConfig

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfMatchConfig to be added or updated

object (netgate.vpf.VpfMatchConfig)

The packet attributes to match in an VPF rule.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter": {
    }
}

removes netgate.vpf.VpfMatchConfig

removes netgate.vpf.VpfMatchConfig

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/match"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.VpfEndpoint

The source pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/match/from"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

creates netgate.vpf.VpfEndpoint

The source pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfEndpoint to be added to list

object (netgate.vpf.VpfEndpoint)

VPF source or destination endpoint

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

creates or updates netgate.vpf.VpfEndpoint

The source pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfEndpoint to be added or updated

object (netgate.vpf.VpfEndpoint)

VPF source or destination endpoint

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

removes netgate.vpf.VpfEndpoint

The source pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/match/from"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.VpfEndpoint

The destination pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/match/to"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

creates netgate.vpf.VpfEndpoint

The destination pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfEndpoint to be added to list

object (netgate.vpf.VpfEndpoint)

VPF source or destination endpoint

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

creates or updates netgate.vpf.VpfEndpoint

The destination pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.VpfEndpoint to be added or updated

object (netgate.vpf.VpfEndpoint)

VPF source or destination endpoint

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

removes netgate.vpf.VpfEndpoint

The destination pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/match/to"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.natrulesets.ruleset.rules.rule.Translation

NAT translation information.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/translation"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:translation": {
    }
}

creates netgate.vpf.vpfconfig.natrulesets.ruleset.rules.rule.Translation

NAT translation information.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.natrulesets.ruleset.rules.rule.Translation to be added to list

netgate-vpf:if-name
string

Use IF addresses for translation.

netgate-vpf:table-name
string

Translation table name.

netgate-vpf:port
integer <int32>

Port to use for translation. 0 means no port.

netgate-vpf:prefix
string

Translation prefix.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:if-name": "string",
  • "netgate-vpf:table-name": "string",
  • "netgate-vpf:port": 0,
  • "netgate-vpf:prefix": "string"
}

creates or updates netgate.vpf.vpfconfig.natrulesets.ruleset.rules.rule.Translation

NAT translation information.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.natrulesets.ruleset.rules.rule.Translation to be added or updated

object (netgate.vpf.vpfconfig.natrulesets.ruleset.rules.rule.Translation)

NAT translation information.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:translation": {
    }
}

removes netgate.vpf.vpfconfig.natrulesets.ruleset.rules.rule.Translation

NAT translation information.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/translation"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.Options

VPF interface configuration and enablement options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:options": {
    }
}

creates netgate.vpf.vpfconfig.Options

VPF interface configuration and enablement options.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.Options to be added to list

object (netgate.vpf.vpfconfig.options.Runtime)

Runtime options.

object (netgate.vpf.vpfconfig.options.Interfaces)

The names of filtering and NAT rulesets applied to interfaces.

object (netgate.vpf.vpfconfig.options.Startup)

Startup options.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:runtime": {
    },
  • "netgate-vpf:interfaces": {
    },
  • "netgate-vpf:startup": {
    }
}

creates or updates netgate.vpf.vpfconfig.Options

VPF interface configuration and enablement options.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.Options to be added or updated

object (netgate.vpf.vpfconfig.Options)

VPF interface configuration and enablement options.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:options": {
    }
}

removes netgate.vpf.vpfconfig.Options

VPF interface configuration and enablement options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.options.Interfaces

The names of filtering and NAT rulesets applied to interfaces.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/interfaces"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:interfaces": {
    }
}

creates netgate.vpf.vpfconfig.options.Interfaces

The names of filtering and NAT rulesets applied to interfaces.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.Interfaces to be added to list

Array of objects (netgate.vpf.vpfconfig.options.interfaces.Interface)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:interface": [
    ]
}

creates or updates netgate.vpf.vpfconfig.options.Interfaces

The names of filtering and NAT rulesets applied to interfaces.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.Interfaces to be added or updated

object (netgate.vpf.vpfconfig.options.Interfaces)

The names of filtering and NAT rulesets applied to interfaces.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:interfaces": {
    }
}

removes netgate.vpf.vpfconfig.options.Interfaces

The names of filtering and NAT rulesets applied to interfaces.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/interfaces"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

creates netgate.vpf.vpfconfig.options.interfaces.Interface

creates netgate.vpf.vpfconfig.options.interfaces.Interface

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.interfaces.Interface to be added to list

netgate-vpf:nat-ruleset
string

The name of the NAT ruleset on this interface.

netgate-vpf:filter-ruleset
string

The name of the filter ruleset on this interface.

netgate-vpf:if-name
string

The name of an interface.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:nat-ruleset": "string",
  • "netgate-vpf:filter-ruleset": "string",
  • "netgate-vpf:if-name": "string"
}

returns netgate.vpf.vpfconfig.options.interfaces.Interface

returns netgate.vpf.vpfconfig.options.interfaces.Interface

path Parameters
if-name
required
string

Id of interface

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/interfaces/interface=%7Bif-name%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:interface": {
    }
}

creates or updates netgate.vpf.vpfconfig.options.interfaces.Interface

creates or updates netgate.vpf.vpfconfig.options.interfaces.Interface

path Parameters
if-name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.interfaces.Interface to be added or updated

object (netgate.vpf.vpfconfig.options.interfaces.Interface)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:interface": {
    }
}

removes netgate.vpf.vpfconfig.options.interfaces.Interface

removes netgate.vpf.vpfconfig.options.interfaces.Interface

path Parameters
if-name
required
string

Id of interface

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/interfaces/interface=%7Bif-name%7D"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.options.Runtime

Runtime options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:runtime": {
    }
}

creates netgate.vpf.vpfconfig.options.Runtime

Runtime options.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.Runtime to be added to list

object (netgate.vpf.vpfconfig.options.runtime.Tcp)

TCP.

object (netgate.vpf.vpfconfig.options.runtime.DropOptions)

Drop packets having IP options.

object (netgate.vpf.vpfconfig.options.runtime.Timeouts)

Timeouts.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:tcp": {
    },
  • "netgate-vpf:drop-options": {
    },
  • "netgate-vpf:timeouts": {
    }
}

creates or updates netgate.vpf.vpfconfig.options.Runtime

Runtime options.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.Runtime to be added or updated

object (netgate.vpf.vpfconfig.options.Runtime)

Runtime options.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:runtime": {
    }
}

removes netgate.vpf.vpfconfig.options.Runtime

Runtime options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.options.runtime.DropOptions

Drop packets having IP options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime/drop-options"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:drop-options": {
    }
}

creates netgate.vpf.vpfconfig.options.runtime.DropOptions

Drop packets having IP options.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.runtime.DropOptions to be added to list

netgate-vpf:ip4
boolean
Default: false

Drop IPv4 packets having IP options.

netgate-vpf:ip6
boolean
Default: false

Drop IPv6 packets having IP options.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ip4": false,
  • "netgate-vpf:ip6": false
}

creates or updates netgate.vpf.vpfconfig.options.runtime.DropOptions

Drop packets having IP options.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.runtime.DropOptions to be added or updated

object (netgate.vpf.vpfconfig.options.runtime.DropOptions)

Drop packets having IP options.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:drop-options": {
    }
}

removes netgate.vpf.vpfconfig.options.runtime.DropOptions

Drop packets having IP options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime/drop-options"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.options.runtime.Tcp

TCP.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime/tcp"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:tcp": {
    }
}

creates netgate.vpf.vpfconfig.options.runtime.Tcp

TCP.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.runtime.Tcp to be added to list

netgate-vpf:strict-rst-order
boolean
Default: true

Enforce strict TCP RST order.

netgate-vpf:max-ack-win
integer <int64>
Default: 66000

Maximum TCP ACK window.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:strict-rst-order": true,
  • "netgate-vpf:max-ack-win": 66000
}

creates or updates netgate.vpf.vpfconfig.options.runtime.Tcp

TCP.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.runtime.Tcp to be added or updated

object (netgate.vpf.vpfconfig.options.runtime.Tcp)

TCP.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:tcp": {
    }
}

removes netgate.vpf.vpfconfig.options.runtime.Tcp

TCP.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime/tcp"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.options.runtime.Timeouts

Timeouts.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime/timeouts"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:timeouts": {
    }
}

creates netgate.vpf.vpfconfig.options.runtime.Timeouts

Timeouts.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.runtime.Timeouts to be added to list

object (netgate.vpf.vpfconfig.options.runtime.timeouts.Tcp)

TCP timeouts.

object (netgate.vpf.vpfconfig.options.runtime.timeouts.Generic)

Generic timeouts.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:tcp": {
    },
  • "netgate-vpf:generic": {
    }
}

creates or updates netgate.vpf.vpfconfig.options.runtime.Timeouts

Timeouts.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.runtime.Timeouts to be added or updated

object (netgate.vpf.vpfconfig.options.runtime.Timeouts)

Timeouts.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:timeouts": {
    }
}

removes netgate.vpf.vpfconfig.options.runtime.Timeouts

Timeouts.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime/timeouts"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.options.runtime.timeouts.Generic

Generic timeouts.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime/timeouts/generic"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:generic": {
    }
}

creates netgate.vpf.vpfconfig.options.runtime.timeouts.Generic

Generic timeouts.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.runtime.timeouts.Generic to be added to list

netgate-vpf:established
integer <int64>
Default: 60

Established state.

netgate-vpf:new
integer <int64>
Default: 30

New state.

netgate-vpf:closed
integer <int64>
Default: 0

Closed state.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:established": 60,
  • "netgate-vpf:new": 30,
  • "netgate-vpf:closed": 0
}

creates or updates netgate.vpf.vpfconfig.options.runtime.timeouts.Generic

Generic timeouts.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.runtime.timeouts.Generic to be added or updated

object (netgate.vpf.vpfconfig.options.runtime.timeouts.Generic)

Generic timeouts.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:generic": {
    }
}

removes netgate.vpf.vpfconfig.options.runtime.timeouts.Generic

Generic timeouts.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime/timeouts/generic"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.options.runtime.timeouts.Tcp

TCP timeouts.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime/timeouts/tcp"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:tcp": {
    }
}

creates netgate.vpf.vpfconfig.options.runtime.timeouts.Tcp

TCP timeouts.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.runtime.timeouts.Tcp to be added to list

netgate-vpf:established
integer <int64>
Default: 86400

Established state.

netgate-vpf:new
integer <int64>
Default: 30

New state.

netgate-vpf:closed
integer <int64>
Default: 10

Closed state.

netgate-vpf:time-wait
integer <int64>
Default: 240

Time-wait state.

netgate-vpf:half-closed
integer <int64>
Default: 21600

Half-closed state.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:established": 86400,
  • "netgate-vpf:new": 30,
  • "netgate-vpf:closed": 10,
  • "netgate-vpf:time-wait": 240,
  • "netgate-vpf:half-closed": 21600
}

creates or updates netgate.vpf.vpfconfig.options.runtime.timeouts.Tcp

TCP timeouts.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.runtime.timeouts.Tcp to be added or updated

object (netgate.vpf.vpfconfig.options.runtime.timeouts.Tcp)

TCP timeouts.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:tcp": {
    }
}

removes netgate.vpf.vpfconfig.options.runtime.timeouts.Tcp

TCP timeouts.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/runtime/timeouts/tcp"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.options.Startup

Startup options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/startup"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:startup": {
    }
}

creates netgate.vpf.vpfconfig.options.Startup

Startup options.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.Startup to be added to list

object (netgate.vpf.vpfconfig.options.startup.MaxConnectionsPerThread)

Maximum connections per thread.

object (netgate.vpf.vpfconfig.options.startup.PortMapping)

Port mapping.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:max-connections-per-thread": {
    },
  • "netgate-vpf:port-mapping": {
    }
}

creates or updates netgate.vpf.vpfconfig.options.Startup

Startup options.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.Startup to be added or updated

object (netgate.vpf.vpfconfig.options.Startup)

Startup options.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:startup": {
    }
}

removes netgate.vpf.vpfconfig.options.Startup

Startup options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/startup"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.options.startup.MaxConnectionsPerThread

Maximum connections per thread.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/startup/max-connections-per-thread"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:max-connections-per-thread": {
    }
}

creates netgate.vpf.vpfconfig.options.startup.MaxConnectionsPerThread

Maximum connections per thread.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.startup.MaxConnectionsPerThread to be added to list

netgate-vpf:ip4
integer <int64>
Default: 131072

Maximum IPv4 connections per thread.

netgate-vpf:ip6
integer <int64>
Default: 32768

Maximum IPv6 connections per thread.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ip4": 131072,
  • "netgate-vpf:ip6": 32768
}

creates or updates netgate.vpf.vpfconfig.options.startup.MaxConnectionsPerThread

Maximum connections per thread.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.startup.MaxConnectionsPerThread to be added or updated

object (netgate.vpf.vpfconfig.options.startup.MaxConnectionsPerThread)

Maximum connections per thread.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:max-connections-per-thread": {
    }
}

removes netgate.vpf.vpfconfig.options.startup.MaxConnectionsPerThread

Maximum connections per thread.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/startup/max-connections-per-thread"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.options.startup.PortMapping

Port mapping.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/startup/port-mapping"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:port-mapping": {
    }
}

creates netgate.vpf.vpfconfig.options.startup.PortMapping

Port mapping.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.startup.PortMapping to be added to list

netgate-vpf:max-port
integer <int32>
Default: 49151

Highest port used for port mapping.

netgate-vpf:min-port
integer <int32>
Default: 1024

Lowest port used for port mapping.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:max-port": 49151,
  • "netgate-vpf:min-port": 1024
}

creates or updates netgate.vpf.vpfconfig.options.startup.PortMapping

Port mapping.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.options.startup.PortMapping to be added or updated

object (netgate.vpf.vpfconfig.options.startup.PortMapping)

Port mapping.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:port-mapping": {
    }
}

removes netgate.vpf.vpfconfig.options.startup.PortMapping

Port mapping.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/options/startup/port-mapping"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.PrefixTables

Tables of named IP prefix lists.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/prefix-tables"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:prefix-tables": {
    }
}

creates netgate.vpf.vpfconfig.PrefixTables

Tables of named IP prefix lists.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.PrefixTables to be added to list

Array of objects (netgate.vpf.vpfconfig.prefixtables.Table)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:table": [
    ]
}

creates or updates netgate.vpf.vpfconfig.PrefixTables

Tables of named IP prefix lists.

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.PrefixTables to be added or updated

object (netgate.vpf.vpfconfig.PrefixTables)

Tables of named IP prefix lists.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:prefix-tables": {
    }
}

removes netgate.vpf.vpfconfig.PrefixTables

Tables of named IP prefix lists.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/prefix-tables"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

creates netgate.vpf.vpfconfig.prefixtables.Table

creates netgate.vpf.vpfconfig.prefixtables.Table

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.prefixtables.Table to be added to list

netgate-vpf:name
string

The name of an IP prefix table.

netgate-vpf:description
string

A text description of the VPF prefix table.

object (netgate.vpf.vpfconfig.prefixtables.table.Prefixes)

Each table is a named set of IP prefixes.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:name": "string",
  • "netgate-vpf:description": "string",
  • "netgate-vpf:prefixes": {
    }
}

returns netgate.vpf.vpfconfig.prefixtables.Table

returns netgate.vpf.vpfconfig.prefixtables.Table

path Parameters
name
required
string

Id of table

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/prefix-tables/table=%7Bname%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:table": {
    }
}

creates or updates netgate.vpf.vpfconfig.prefixtables.Table

creates or updates netgate.vpf.vpfconfig.prefixtables.Table

path Parameters
name
required
string

Id of table

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.prefixtables.Table to be added or updated

object (netgate.vpf.vpfconfig.prefixtables.Table)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:table": {
    }
}

removes netgate.vpf.vpfconfig.prefixtables.Table

removes netgate.vpf.vpfconfig.prefixtables.Table

path Parameters
name
required
string

Id of table

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/prefix-tables/table=%7Bname%7D"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

returns netgate.vpf.vpfconfig.prefixtables.table.Prefixes

Each table is a named set of IP prefixes.

path Parameters
name
required
string

Id of table

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/prefix-tables/table=%7Bname%7D/prefixes"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:prefixes": {
    }
}

creates netgate.vpf.vpfconfig.prefixtables.table.Prefixes

Each table is a named set of IP prefixes.

path Parameters
name
required
string

Id of table

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.prefixtables.table.Prefixes to be added to list

netgate-vpf:prefix
Array of strings

Either an IPv4 or IPv6 prefix.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:prefix": [
    ]
}

creates or updates netgate.vpf.vpfconfig.prefixtables.table.Prefixes

Each table is a named set of IP prefixes.

path Parameters
name
required
string

Id of table

Request Body schema: application/yang-data+json

netgate.vpf.vpfconfig.prefixtables.table.Prefixes to be added or updated

object (netgate.vpf.vpfconfig.prefixtables.table.Prefixes)

Each table is a named set of IP prefixes.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vpf:prefixes": {
    }
}

removes netgate.vpf.vpfconfig.prefixtables.table.Prefixes

Each table is a named set of IP prefixes.

path Parameters
name
required
string

Id of table

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-config/prefix-tables/table=%7Bname%7D/prefixes"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

vpf-state

returns netgate.vpf.VpfState

Netbsd Packet Filter (VPF) state data. It consists of a set of named tables containing IP prefixes, a set of named filtering rules, a set of named NAT rules, and params.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:vpf-state": {
    }
}

returns netgate.vpf.vpfstate.FilterRulesets

A list of named VPF filter rulesets.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/filter-rulesets"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter-rulesets": {
    }
}

returns netgate.vpf.vpfstate.filterrulesets.Ruleset

returns netgate.vpf.vpfstate.filterrulesets.Ruleset

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/filter-rulesets/ruleset=%7Bname%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ruleset": {
    }
}

returns netgate.vpf.vpfstate.filterrulesets.ruleset.Rules

A list of filter rules within a ruleset ordered by sequence number.

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/filter-rulesets/ruleset=%7Bname%7D/rules"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rules": {
    }
}

returns netgate.vpf.vpfstate.filterrulesets.ruleset.rules.Rule

returns netgate.vpf.vpfstate.filterrulesets.ruleset.rules.Rule

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rule": {
    }
}

returns netgate.vpf.VpfMatchState

returns netgate.vpf.VpfMatchState

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/filter"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter": {
    }
}

returns netgate.vpf.VpfEndpoint

The source pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/filter/from"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

returns netgate.vpf.VpfEndpoint

The destination pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/filter-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/filter/to"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

returns netgate.vpf.vpfstate.Ipfix

IPFIX exporting options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/ipfix"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ipfix": {
    }
}

returns netgate.vpf.vpfstate.NatRulesets

A list of VPF NAT rulesets.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/nat-rulesets"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:nat-rulesets": {
    }
}

returns netgate.vpf.vpfstate.natrulesets.Ruleset

returns netgate.vpf.vpfstate.natrulesets.Ruleset

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/nat-rulesets/ruleset=%7Bname%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:ruleset": {
    }
}

returns netgate.vpf.vpfstate.natrulesets.ruleset.Rules

A list of NAT rules within a ruleset ordered by sequence number.

path Parameters
name
required
string

Id of ruleset

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/nat-rulesets/ruleset=%7Bname%7D/rules"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rules": {
    }
}

returns netgate.vpf.vpfstate.natrulesets.ruleset.rules.Rule

returns netgate.vpf.vpfstate.natrulesets.ruleset.rules.Rule

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:rule": {
    }
}

returns netgate.vpf.VpfMatchState

returns netgate.vpf.VpfMatchState

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/match"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:filter": {
    }
}

returns netgate.vpf.VpfEndpoint

The source pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/match/from"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

returns netgate.vpf.VpfEndpoint

The destination pattern to match in an VPF rule.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/match/to"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:from": {
    }
}

returns netgate.vpf.vpfstate.natrulesets.ruleset.rules.rule.Translation

NAT translation information.

path Parameters
name
required
string

Id of ruleset

sequence
required
integer <int64>

Id of rule

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/nat-rulesets/ruleset=%7Bname%7D/rules/rule=%7Bsequence%7D/translation"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:translation": {
    }
}

returns netgate.vpf.vpfstate.Options

VPF interface state and enablement options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:options": {
    }
}

returns netgate.vpf.vpfstate.options.Interfaces

The names of filtering and NAT rulesets applied to interfaces.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options/interfaces"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:interfaces": {
    }
}

returns netgate.vpf.vpfstate.options.interfaces.Interface

returns netgate.vpf.vpfstate.options.interfaces.Interface

path Parameters
if-name
required
string

Id of interface

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options/interfaces/interface=%7Bif-name%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:interface": {
    }
}

returns netgate.vpf.vpfstate.options.Runtime

Runtime options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options/runtime"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:runtime": {
    }
}

returns netgate.vpf.vpfstate.options.runtime.DropOptions

Drop packets having IP options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options/runtime/drop-options"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:drop-options": {
    }
}

returns netgate.vpf.vpfstate.options.runtime.Tcp

TCP.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options/runtime/tcp"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:tcp": {
    }
}

returns netgate.vpf.vpfstate.options.runtime.Timeouts

Timeouts.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options/runtime/timeouts"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:timeouts": {
    }
}

returns netgate.vpf.vpfstate.options.runtime.timeouts.Generic

Generic timeouts.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options/runtime/timeouts/generic"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:generic": {
    }
}

returns netgate.vpf.vpfstate.options.runtime.timeouts.Tcp

TCP timeouts.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options/runtime/timeouts/tcp"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:tcp": {
    }
}

returns netgate.vpf.vpfstate.options.Startup

Startup options.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options/startup"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:startup": {
    }
}

returns netgate.vpf.vpfstate.options.startup.MaxConnectionsPerThread

Maximum connections per thread.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options/startup/max-connections-per-thread"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:max-connections-per-thread": {
    }
}

returns netgate.vpf.vpfstate.options.startup.PortMapping

Port mapping.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/options/startup/port-mapping"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:port-mapping": {
    }
}

returns netgate.vpf.vpfstate.PrefixTables

Tables of named IP prefix lists.

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/prefix-tables"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:prefix-tables": {
    }
}

returns netgate.vpf.vpfstate.prefixtables.Table

returns netgate.vpf.vpfstate.prefixtables.Table

path Parameters
name
required
string

Id of table

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/prefix-tables/table=%7Bname%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:table": {
    }
}

returns netgate.vpf.vpfstate.prefixtables.table.HashBuckets

Hash buckets.

path Parameters
name
required
string

Id of table

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/prefix-tables/table=%7Bname%7D/hash-buckets"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:hash-buckets": {
    }
}

returns netgate.vpf.vpfstate.prefixtables.table.Prefixes

Each table is a named set of IP prefixes.

path Parameters
name
required
string

Id of table

Responses

Request samples 

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "http://hostname/restconf/data/netgate-vpf:vpf-state/prefix-tables/table=%7Bname%7D/prefixes"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

Response samples

Content type
application/yang-data+json
{
  • "netgate-vpf:prefixes": {
    }
}