Netgate TNSR Logo
API docs by Redocly

netgate-interface API (25.02)

This YANG module provides a data model for network interfaces.

Copyright 2017-2025 Rubicon Communications, LLC.

interfaces-config

returns netgate.interface.InterfacesConfig

Interface configuration parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-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-interface:interfaces-config": {
    }
}

creates netgate.interface.InterfacesConfig

Interface configuration parameters.

Request Body schema: application/yang-data+json

netgate.interface.InterfacesConfig to be added to list

object (netgate.vhost.user.interfacesconfig.VhostUserInterfaces)

Data of the vhost-user interfaces.

object (netgate.wireguard.interfacesconfig.WireguardInterfaces)

Wireguard interface.

object (netgate.interface.interfacesconfig.BondTable)

Bond interface configuration table.

object (netgate.interface.interfacesconfig.LoopbackTable)

Loopback name table.

object (netgate.interface.interfacesconfig.BridgeTable)

Bridge mapping table.

object (netgate.interface.interfacesconfig.Subinterfaces)

An interface may have subinterfaces.

object (netgate.interface.interfacesconfig.TapTable)

Host Tap interface configuration table.

Array of objects (netgate.interface.interfacesconfig.Interface)

The list of configured interfaces on the device.

object (netgate.interface.interfacesconfig.MemifTable)

Host memif interface configuration table.

object (netgate.interface.interfacesconfig.SocketTable)

Host memif socket table.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vhost-user:vhost-user-interfaces": {
    },
  • "netgate-wireguard:wireguard-interfaces": {
    },
  • "bond-table": {
    },
  • "loopback-table": {
    },
  • "bridge-table": {
    },
  • "subinterfaces": {
    },
  • "tap-table": {
    },
  • "interface": [
    ],
  • "memif-table": {
    },
  • "socket-table": {
    }
}

creates or updates netgate.interface.InterfacesConfig

Interface configuration parameters.

Request Body schema: application/yang-data+json

netgate.interface.InterfacesConfig to be added or updated

object (netgate.interface.InterfacesConfig)

Interface configuration parameters.

Responses

Request samples

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

removes netgate.interface.InterfacesConfig

Interface configuration parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-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.interface.interfacesconfig.BondTable

Bond interface configuration table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bond-table"

	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-interface:bond-table": {
    }
}

creates netgate.interface.interfacesconfig.BondTable

Bond interface configuration table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.BondTable to be added to list

Array of objects (netgate.interface.interfacesconfig.bondtable.Bond)

Bond interface.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.BondTable

Bond interface configuration table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.BondTable to be added or updated

object (netgate.interface.interfacesconfig.BondTable)

Bond interface configuration table.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.BondTable

Bond interface configuration table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bond-table"

	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.interface.interfacesconfig.bondtable.Bond

Bond interface.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.bondtable.Bond to be added to list

netgate-interface:mode
string (netgate.interface.BondMode)
Enum: "round-robin" "active-backup" "xor" "broadcast" "lacp"
netgate-interface:mac-address
string

The MAC address for the interface.

netgate-interface:load-balance
string (netgate.interface.LoadBalance)
Enum: "l2" "l34" "l23"
netgate-interface:instance
integer <int64>

The identifier. A unique number for this bond interface.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:mode": "round-robin",
  • "netgate-interface:mac-address": "string",
  • "netgate-interface:load-balance": "l2",
  • "netgate-interface:instance": 0
}

returns netgate.interface.interfacesconfig.bondtable.Bond

Bond interface.

path Parameters
instance
required
integer <int64>

Id of bond

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bond-table/bond=%7Binstance%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-interface:bond": {
    }
}

creates or updates netgate.interface.interfacesconfig.bondtable.Bond

Bond interface.

path Parameters
instance
required
integer <int64>

Id of bond

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.bondtable.Bond to be added or updated

object (netgate.interface.interfacesconfig.bondtable.Bond)

Bond interface.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.bondtable.Bond

Bond interface.

path Parameters
instance
required
integer <int64>

Id of bond

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bond-table/bond=%7Binstance%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.interface.interfacesconfig.BridgeTable

Bridge mapping table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bridge-table"

	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-interface:bridge-table": {
    }
}

creates netgate.interface.interfacesconfig.BridgeTable

Bridge mapping table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.BridgeTable to be added to list

Array of objects (netgate.interface.interfacesconfig.bridgetable.BridgeEntry)

Bridge Domain Id.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.BridgeTable

Bridge mapping table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.BridgeTable to be added or updated

object (netgate.interface.interfacesconfig.BridgeTable)

Bridge mapping table.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.BridgeTable

Bridge mapping table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bridge-table"

	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.interface.interfacesconfig.bridgetable.BridgeEntry

Bridge Domain Id.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.bridgetable.BridgeEntry to be added to list

netgate-interface:learn
boolean

Learning on all interfaces in the bd

netgate-interface:forward
boolean

Forwarding on all interfaces in the bd

netgate-interface:bdi
integer <int64>

The Bridge Domain Identifier. A unique number for this entry.

netgate-interface:mac-age
integer <int32>

MAC aging time in min, 0 for disabled.

netgate-interface:description
string

A textual description of the bridge.

object (netgate.interface.interfacesconfig.bridgetable.bridgeentry.BridgeArpTable)

Bridge ARP Entry Table.

netgate-interface:arp-term
boolean

ARP termination in the bd

netgate-interface:uu-flood
boolean

Unknown unicast flood in the bd

netgate-interface:flood
boolean

Broadcast/multicast flooding in the bd

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:learn": true,
  • "netgate-interface:forward": true,
  • "netgate-interface:bdi": 0,
  • "netgate-interface:mac-age": 0,
  • "netgate-interface:description": "string",
  • "netgate-interface:bridge-arp-table": {
    },
  • "netgate-interface:arp-term": true,
  • "netgate-interface:uu-flood": true,
  • "netgate-interface:flood": true
}

returns netgate.interface.interfacesconfig.bridgetable.BridgeEntry

Bridge Domain Id.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bridge-table/bridge-entry=%7Bbdi%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-interface:bridge-entry": {
    }
}

creates or updates netgate.interface.interfacesconfig.bridgetable.BridgeEntry

Bridge Domain Id.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.bridgetable.BridgeEntry to be added or updated

object (netgate.interface.interfacesconfig.bridgetable.BridgeEntry)

Bridge Domain Id.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.bridgetable.BridgeEntry

Bridge Domain Id.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bridge-table/bridge-entry=%7Bbdi%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.interface.interfacesconfig.bridgetable.bridgeentry.BridgeArpTable

Bridge ARP Entry Table.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bridge-table/bridge-entry=%7Bbdi%7D/bridge-arp-table"

	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-interface:bridge-arp-table": {
    }
}

creates netgate.interface.interfacesconfig.bridgetable.bridgeentry.BridgeArpTable

Bridge ARP Entry Table.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.bridgetable.bridgeentry.BridgeArpTable to be added to list

Array of objects (netgate.interface.interfacesconfig.bridgetable.bridgeentry.bridgearptable.BridgeArpEntry)

Bridge ARP entry table.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.bridgetable.bridgeentry.BridgeArpTable

Bridge ARP Entry Table.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.bridgetable.bridgeentry.BridgeArpTable to be added or updated

object (netgate.interface.interfacesconfig.bridgetable.bridgeentry.BridgeArpTable)

Bridge ARP Entry Table.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.bridgetable.bridgeentry.BridgeArpTable

Bridge ARP Entry Table.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bridge-table/bridge-entry=%7Bbdi%7D/bridge-arp-table"

	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.interface.interfacesconfig.bridgetable.bridgeentry.bridgearptable.BridgeArpEntry

Bridge ARP entry table.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.bridgetable.bridgeentry.bridgearptable.BridgeArpEntry to be added to list

netgate-interface:mac-address
string

The MAC address of an ARP entry.

netgate-interface:ip-address
string

The IPv4 or IPv6 address of an ARP entry.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:mac-address": "string",
  • "netgate-interface:ip-address": "string"
}

returns netgate.interface.interfacesconfig.bridgetable.bridgeentry.bridgearptable.BridgeArpEntry

Bridge ARP entry table.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

ip-address
required
string

Id of bridge-arp-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bridge-table/bridge-entry=%7Bbdi%7D/bridge-arp-table/bridge-arp-entry=%7Bip-address%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-interface:bridge-arp-entry": {
    }
}

creates or updates netgate.interface.interfacesconfig.bridgetable.bridgeentry.bridgearptable.BridgeArpEntry

Bridge ARP entry table.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

ip-address
required
string

Id of bridge-arp-entry

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.bridgetable.bridgeentry.bridgearptable.BridgeArpEntry to be added or updated

object (netgate.interface.interfacesconfig.bridgetable.bridgeentry.bridgearptable.BridgeArpEntry)

Bridge ARP entry table.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.bridgetable.bridgeentry.bridgearptable.BridgeArpEntry

Bridge ARP entry table.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

ip-address
required
string

Id of bridge-arp-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/bridge-table/bridge-entry=%7Bbdi%7D/bridge-arp-table/bridge-arp-entry=%7Bip-address%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))

}

creates netgate.interface.interfacesconfig.Interface

The list of configured interfaces on the device.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.Interface to be added to list

object (netgate.interface.extensions.InterfaceStateExtensions)

The interface extensions state data contains interface information that is not covered by standard data models.

mac-address
string

The Media Access Control (MAC) address of the interface.

host-tap-name
string

If this interface is associated with a host tap, this field names that host tap interface.

description
string

A textual description of the interface.

collect-detailed-stats
boolean

enable detailed counter keeping in VPP

vrf
string

The name of the VRF this interface is bound to.

object (netgate.interface.interfacesconfig.interface.Bond)

If the interface is being used as a slave, this node contains the corresponding bond ID and slave options.

enabled
boolean

This leaf contains the configured, desired state of the interface.

mtu
integer <int32>

The size, in octets, of the largest packet that the interface will send and receive.

rx-mode
string (netgate.interface.IntfRxMode)
Enum: "polling" "interrupt" "adaptive"
object (netgate.interface.interfacesconfig.interface.Ipv4)

Parameters for the IPv4 address family.

object (netgate.interface.interfacesconfig.interface.AccessList)

If the interface has any Access Control Lists, they are listed here in two groups: those that apply to packet ingress and those that apply to egresss. The two sets of ACLs are sorted independenty and applied in ascending sequence-number order.

object (netgate.interface.interfacesconfig.interface.DhcpClient)

If the interface is configured using a DHCP client, that configuration is contained here.

object (netgate.interface.interfacesconfig.interface.Ipv6)

Parameters for the IPv6 address family.

nat-interface
string (netgate.nat.NatSide)
Enum: "none" "inside" "outside"
name
string

The name of the interface.

object (netgate.interface.interfacesconfig.interface.Bridge)

If the interface is being used as a bridge, this node contains the corresponding Bridge Domain Id, Split Horizon, and/or Bridge Virtual Id information.

object (netgate.interface.interfacesconfig.interface.Map)

Per-interface parameters for MAP-E and MAP-T.

object (netgate.interface.interfacesconfig.interface.VlanTagRewrite)
object (netgate.interface.interfacesconfig.interface.Lldp)

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface-extensions:rx-queues": {
    },
  • "mac-address": "string",
  • "host-tap-name": "string",
  • "description": "string",
  • "collect-detailed-stats": true,
  • "vrf": "string",
  • "bond": {
    },
  • "enabled": true,
  • "mtu": 0,
  • "rx-mode": "polling",
  • "ipv4": {
    },
  • "access-list": {
    },
  • "dhcp-client": {
    },
  • "ipv6": {
    },
  • "nat-interface": "none",
  • "name": "string",
  • "bridge": {
    },
  • "map": {
    },
  • "vlan-tag-rewrite": {
    },
  • "lldp": {
    }
}

returns netgate.interface.interfacesconfig.Interface

The list of configured interfaces on the device.

path Parameters
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-interface:interfaces-config/interface=%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-interface:interface": {
    }
}

creates or updates netgate.interface.interfacesconfig.Interface

The list of configured interfaces on the device.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.Interface to be added or updated

object (netgate.interface.interfacesconfig.Interface)

The list of configured interfaces on the device.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.Interface

The list of configured interfaces on the device.

path Parameters
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-interface:interfaces-config/interface=%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.interface.interfacesconfig.interface.AccessList

If the interface has any Access Control Lists, they are listed here in two groups: those that apply to packet ingress and those that apply to egresss. The two sets of ACLs are sorted independenty and applied in ascending sequence-number order.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/access-list"

	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-interface:access-list": {
    }
}

creates netgate.interface.interfacesconfig.interface.AccessList

If the interface has any Access Control Lists, they are listed here in two groups: those that apply to packet ingress and those that apply to egresss. The two sets of ACLs are sorted independenty and applied in ascending sequence-number order.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.AccessList to be added to list

object (netgate.interface.interfacesconfig.interface.accesslist.Output)

These are the ACL rule-sets that apply to egress packets.

object (netgate.interface.interfacesconfig.interface.accesslist.Input)

These are the ACL rule-sets that apply to ingress packets.

object (netgate.interface.interfacesconfig.interface.accesslist.Macip)

An interface may also have at most one ACL based upon a combination of MAC address and IP. If that ACL is present, it is always on the ingress packets.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:output": {
    },
  • "netgate-interface:input": {
    },
  • "netgate-interface:macip": {
    }
}

creates or updates netgate.interface.interfacesconfig.interface.AccessList

If the interface has any Access Control Lists, they are listed here in two groups: those that apply to packet ingress and those that apply to egresss. The two sets of ACLs are sorted independenty and applied in ascending sequence-number order.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.AccessList to be added or updated

object (netgate.interface.interfacesconfig.interface.AccessList)

If the interface has any Access Control Lists, they are listed here in two groups: those that apply to packet ingress and those that apply to egresss. The two sets of ACLs are sorted independenty and applied in ascending sequence-number order.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.AccessList

If the interface has any Access Control Lists, they are listed here in two groups: those that apply to packet ingress and those that apply to egresss. The two sets of ACLs are sorted independenty and applied in ascending sequence-number order.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/access-list"

	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.interface.interfacesconfig.interface.accesslist.Input

These are the ACL rule-sets that apply to ingress packets.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/access-list/input"

	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-interface:input": {
    }
}

creates netgate.interface.interfacesconfig.interface.accesslist.Input

These are the ACL rule-sets that apply to ingress packets.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.accesslist.Input to be added to list

Array of objects (netgate.interface.interfacesconfig.interface.accesslist.input.AclList)

Each ACL rule-set can appear at most once within the input list.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.interface.accesslist.Input

These are the ACL rule-sets that apply to ingress packets.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.accesslist.Input to be added or updated

object (netgate.interface.interfacesconfig.interface.accesslist.Input)

These are the ACL rule-sets that apply to ingress packets.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.accesslist.Input

These are the ACL rule-sets that apply to ingress packets.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/access-list/input"

	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.interface.interfacesconfig.interface.accesslist.input.AclList

Each ACL rule-set can appear at most once within the input list.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.accesslist.input.AclList to be added to list

netgate-interface:sequence
integer <int64>

Set the ordering of the ACLs. Rules are applied in ascending sequence number.

netgate-interface:acl-name
string

This is the name of an ACL rule-set that will be be applied to packets on this interface.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:sequence": 0,
  • "netgate-interface:acl-name": "string"
}

returns netgate.interface.interfacesconfig.interface.accesslist.input.AclList

Each ACL rule-set can appear at most once within the input list.

path Parameters
name
required
string

Id of interface

acl-name
required
string

Id of acl-list

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/interface=%7Bname%7D/access-list/input/acl-list=%7Bacl-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-interface:acl-list": {
    }
}

creates or updates netgate.interface.interfacesconfig.interface.accesslist.input.AclList

Each ACL rule-set can appear at most once within the input list.

path Parameters
name
required
string

Id of interface

acl-name
required
string

Id of acl-list

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.accesslist.input.AclList to be added or updated

object (netgate.interface.interfacesconfig.interface.accesslist.input.AclList)

Each ACL rule-set can appear at most once within the input list.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.accesslist.input.AclList

Each ACL rule-set can appear at most once within the input list.

path Parameters
name
required
string

Id of interface

acl-name
required
string

Id of acl-list

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/interface=%7Bname%7D/access-list/input/acl-list=%7Bacl-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.interface.interfacesconfig.interface.accesslist.Macip

An interface may also have at most one ACL based upon a combination of MAC address and IP. If that ACL is present, it is always on the ingress packets.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/access-list/macip"

	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-interface:macip": {
    }
}

creates netgate.interface.interfacesconfig.interface.accesslist.Macip

An interface may also have at most one ACL based upon a combination of MAC address and IP. If that ACL is present, it is always on the ingress packets.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.accesslist.Macip to be added to list

netgate-interface:macip-name
string

This name references at most one MACIP ingress rule-set from the ACL MACIP tables.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.interface.accesslist.Macip

An interface may also have at most one ACL based upon a combination of MAC address and IP. If that ACL is present, it is always on the ingress packets.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.accesslist.Macip to be added or updated

object (netgate.interface.interfacesconfig.interface.accesslist.Macip)

An interface may also have at most one ACL based upon a combination of MAC address and IP. If that ACL is present, it is always on the ingress packets.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.accesslist.Macip

An interface may also have at most one ACL based upon a combination of MAC address and IP. If that ACL is present, it is always on the ingress packets.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/access-list/macip"

	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.interface.interfacesconfig.interface.accesslist.Output

These are the ACL rule-sets that apply to egress packets.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/access-list/output"

	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-interface:output": {
    }
}

creates netgate.interface.interfacesconfig.interface.accesslist.Output

These are the ACL rule-sets that apply to egress packets.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.accesslist.Output to be added to list

Array of objects (netgate.interface.interfacesconfig.interface.accesslist.output.AclList)

Each ACL rule-set can appear at most once within the output list.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.interface.accesslist.Output

These are the ACL rule-sets that apply to egress packets.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.accesslist.Output to be added or updated

object (netgate.interface.interfacesconfig.interface.accesslist.Output)

These are the ACL rule-sets that apply to egress packets.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.accesslist.Output

These are the ACL rule-sets that apply to egress packets.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/access-list/output"

	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.interface.interfacesconfig.interface.accesslist.output.AclList

Each ACL rule-set can appear at most once within the output list.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.accesslist.output.AclList to be added to list

netgate-interface:sequence
integer <int64>

Set the ordering of the ACLs. Rules are applied in ascending sequence number.

netgate-interface:acl-name
string

This is the name of an ACL rule-set that will be be applied to packets on this interface.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:sequence": 0,
  • "netgate-interface:acl-name": "string"
}

returns netgate.interface.interfacesconfig.interface.accesslist.output.AclList

Each ACL rule-set can appear at most once within the output list.

path Parameters
name
required
string

Id of interface

acl-name
required
string

Id of acl-list

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/interface=%7Bname%7D/access-list/output/acl-list=%7Bacl-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-interface:acl-list": {
    }
}

creates or updates netgate.interface.interfacesconfig.interface.accesslist.output.AclList

Each ACL rule-set can appear at most once within the output list.

path Parameters
name
required
string

Id of interface

acl-name
required
string

Id of acl-list

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.accesslist.output.AclList to be added or updated

object (netgate.interface.interfacesconfig.interface.accesslist.output.AclList)

Each ACL rule-set can appear at most once within the output list.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.accesslist.output.AclList

Each ACL rule-set can appear at most once within the output list.

path Parameters
name
required
string

Id of interface

acl-name
required
string

Id of acl-list

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/interface=%7Bname%7D/access-list/output/acl-list=%7Bacl-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.interface.interfacesconfig.interface.Bond

If the interface is being used as a slave, this node contains the corresponding bond ID and slave options.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/bond"

	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-interface:bond": {
    }
}

creates netgate.interface.interfacesconfig.interface.Bond

If the interface is being used as a slave, this node contains the corresponding bond ID and slave options.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Bond to be added to list

netgate-interface:passive
boolean
Default: false

The slave interface does not initiate the LACP protocol, remote must be active speaker.

netgate-interface:long-timeout
boolean
Default: false

90 seconds VS default 3 seconds neighbor timeout.

netgate-interface:instance
integer <int64>

Bond unique identifier.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:passive": false,
  • "netgate-interface:long-timeout": false,
  • "netgate-interface:instance": 0
}

creates or updates netgate.interface.interfacesconfig.interface.Bond

If the interface is being used as a slave, this node contains the corresponding bond ID and slave options.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Bond to be added or updated

object (netgate.interface.interfacesconfig.interface.Bond)

If the interface is being used as a slave, this node contains the corresponding bond ID and slave options.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.Bond

If the interface is being used as a slave, this node contains the corresponding bond ID and slave options.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/bond"

	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.interface.interfacesconfig.interface.Bridge

If the interface is being used as a bridge, this node contains the corresponding Bridge Domain Id, Split Horizon, and/or Bridge Virtual Id information.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/bridge"

	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-interface:bridge": {
    }
}

creates netgate.interface.interfacesconfig.interface.Bridge

If the interface is being used as a bridge, this node contains the corresponding Bridge Domain Id, Split Horizon, and/or Bridge Virtual Id information.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Bridge to be added to list

netgate-interface:bvi
boolean

Set up the interface as a BVI.

netgate-interface:bdi
integer <int64>

Bridge Domain Id.

netgate-interface:shg
integer <int32>

Split Horizon Group.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:bvi": true,
  • "netgate-interface:bdi": 0,
  • "netgate-interface:shg": 0
}

creates or updates netgate.interface.interfacesconfig.interface.Bridge

If the interface is being used as a bridge, this node contains the corresponding Bridge Domain Id, Split Horizon, and/or Bridge Virtual Id information.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Bridge to be added or updated

object (netgate.interface.interfacesconfig.interface.Bridge)

If the interface is being used as a bridge, this node contains the corresponding Bridge Domain Id, Split Horizon, and/or Bridge Virtual Id information.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.Bridge

If the interface is being used as a bridge, this node contains the corresponding Bridge Domain Id, Split Horizon, and/or Bridge Virtual Id information.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/bridge"

	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.interface.interfacesconfig.interface.DhcpClient

If the interface is configured using a DHCP client, that configuration is contained here.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/dhcp-client"

	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-interface:dhcp-client": {
    }
}

creates netgate.interface.interfacesconfig.interface.DhcpClient

If the interface is configured using a DHCP client, that configuration is contained here.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.DhcpClient to be added to list

netgate-interface:hostname
string

An optional hostname to use.

netgate-interface:enable
boolean
Default: false

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:hostname": "string",
  • "netgate-interface:enable": false
}

creates or updates netgate.interface.interfacesconfig.interface.DhcpClient

If the interface is configured using a DHCP client, that configuration is contained here.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.DhcpClient to be added or updated

object (netgate.interface.interfacesconfig.interface.DhcpClient)

If the interface is configured using a DHCP client, that configuration is contained here.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.DhcpClient

If the interface is configured using a DHCP client, that configuration is contained here.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/dhcp-client"

	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.interface.interfacesconfig.interface.Ipv4

Parameters for the IPv4 address family.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv4"

	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-interface:ipv4": {
    }
}

creates netgate.interface.interfacesconfig.interface.Ipv4

Parameters for the IPv4 address family.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Ipv4 to be added to list

object (netgate.vrrp.interfacesstate.interface.ipv4.Vrrp)

Configures VRRP version 3 for IPv4.

object (netgate.interface.interfacesconfig.interface.ipv4.Tcp)

IPv4 TCP configuration values.

object (netgate.interface.interfacesconfig.interface.ipv4.Address)
object (netgate.interface.interfacesconfig.interface.ipv4.Reassembly)

ip-reassembly feature control.

mtu
integer <int32>

The size, in octets, of the largest IPv4 packet that the interface will send and receive.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-vrrp:vrrp": {
    },
  • "tcp": {
    },
  • "address": {
    },
  • "reassembly": {
    },
  • "mtu": 0
}

creates or updates netgate.interface.interfacesconfig.interface.Ipv4

Parameters for the IPv4 address family.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Ipv4 to be added or updated

object (netgate.interface.interfacesconfig.interface.Ipv4)

Parameters for the IPv4 address family.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.Ipv4

Parameters for the IPv4 address family.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv4"

	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.interface.interfacesconfig.interface.ipv4.Address

returns netgate.interface.interfacesconfig.interface.ipv4.Address

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv4/address"

	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-interface:address": {
    }
}

creates netgate.interface.interfacesconfig.interface.ipv4.Address

creates netgate.interface.interfacesconfig.interface.ipv4.Address

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv4.Address to be added to list

netgate-interface:ip
Array of strings

An IPv4 address on the interface.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.interface.ipv4.Address

creates or updates netgate.interface.interfacesconfig.interface.ipv4.Address

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv4.Address to be added or updated

object (netgate.interface.interfacesconfig.interface.ipv4.Address)

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.ipv4.Address

removes netgate.interface.interfacesconfig.interface.ipv4.Address

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv4/address"

	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.interface.interfacesconfig.interface.ipv4.Reassembly

ip-reassembly feature control.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv4/reassembly"

	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-interface:reassembly": {
    }
}

creates netgate.interface.interfacesconfig.interface.ipv4.Reassembly

ip-reassembly feature control.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv4.Reassembly to be added to list

netgate-interface:enabled
boolean

IPv4 reassembly enabled for interface

netgate-interface:reassembly-type
string (netgate.interface.ReassemblyType)
Enum: "full" "virtual"

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:enabled": true,
  • "netgate-interface:reassembly-type": "full"
}

creates or updates netgate.interface.interfacesconfig.interface.ipv4.Reassembly

ip-reassembly feature control.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv4.Reassembly to be added or updated

object (netgate.interface.interfacesconfig.interface.ipv4.Reassembly)

ip-reassembly feature control.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.ipv4.Reassembly

ip-reassembly feature control.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv4/reassembly"

	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.interface.interfacesconfig.interface.ipv4.Tcp

IPv4 TCP configuration values.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv4/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-interface:tcp": {
    }
}

creates netgate.interface.interfacesconfig.interface.ipv4.Tcp

IPv4 TCP configuration values.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv4.Tcp to be added to list

object (netgate.interface.interfacesconfig.interface.ipv4.tcp.Mss)

IPv4 TCP Maximum Segment Size values.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.interface.ipv4.Tcp

IPv4 TCP configuration values.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv4.Tcp to be added or updated

object (netgate.interface.interfacesconfig.interface.ipv4.Tcp)

IPv4 TCP configuration values.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.ipv4.Tcp

IPv4 TCP configuration values.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv4/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.interface.interfacesconfig.interface.ipv4.tcp.Mss

IPv4 TCP Maximum Segment Size values.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv4/tcp/mss"

	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-interface:mss": {
    }
}

creates netgate.interface.interfacesconfig.interface.ipv4.tcp.Mss

IPv4 TCP Maximum Segment Size values.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv4.tcp.Mss to be added to list

netgate-interface:directions
string (netgate.interface.MssClampDirection)
Enum: "Tx" "Rx" "TxRx"
netgate-interface:value
integer <int32>

The IPv4 TCP maximum segment size.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:directions": "Tx",
  • "netgate-interface:value": 0
}

creates or updates netgate.interface.interfacesconfig.interface.ipv4.tcp.Mss

IPv4 TCP Maximum Segment Size values.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv4.tcp.Mss to be added or updated

object (netgate.interface.interfacesconfig.interface.ipv4.tcp.Mss)

IPv4 TCP Maximum Segment Size values.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.ipv4.tcp.Mss

IPv4 TCP Maximum Segment Size values.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv4/tcp/mss"

	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.interface.interfacesconfig.interface.Ipv6

Parameters for the IPv6 address family.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv6"

	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-interface:ipv6": {
    }
}

creates netgate.interface.interfacesconfig.interface.Ipv6

Parameters for the IPv6 address family.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Ipv6 to be added to list

object (netgate.ipv6.ra.interfacesstate.interface.ipv6.Ipv6RouterAdvertisements)

Parameters of IPv6 Router Advertisements.

object (netgate.vrrp.interfacesstate.interface.ipv6.Vrrp)

Configures VRRP version 3 for IPv6.

object (netgate.interface.interfacesconfig.interface.ipv6.Tcp)

IPv6 TCP configuration values.

object (netgate.interface.interfacesconfig.interface.ipv6.Address)
object (netgate.interface.interfacesconfig.interface.ipv6.Reassembly)

ip-reassembly feature control.

mtu
integer <int64>

The size, in octets, of the largest IPv6 packet that the interface will send and receive.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-ipv6-ra:ipv6-router-advertisements": {
    },
  • "netgate-vrrp:vrrp": {
    },
  • "tcp": {
    },
  • "address": {
    },
  • "reassembly": {
    },
  • "mtu": 0
}

creates or updates netgate.interface.interfacesconfig.interface.Ipv6

Parameters for the IPv6 address family.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Ipv6 to be added or updated

object (netgate.interface.interfacesconfig.interface.Ipv6)

Parameters for the IPv6 address family.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.Ipv6

Parameters for the IPv6 address family.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv6"

	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.interface.interfacesconfig.interface.ipv6.Address

returns netgate.interface.interfacesconfig.interface.ipv6.Address

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv6/address"

	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-interface:address": {
    }
}

creates netgate.interface.interfacesconfig.interface.ipv6.Address

creates netgate.interface.interfacesconfig.interface.ipv6.Address

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv6.Address to be added to list

netgate-interface:ip
Array of strings

An IPv6 address on the interface.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.interface.ipv6.Address

creates or updates netgate.interface.interfacesconfig.interface.ipv6.Address

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv6.Address to be added or updated

object (netgate.interface.interfacesconfig.interface.ipv6.Address)

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.ipv6.Address

removes netgate.interface.interfacesconfig.interface.ipv6.Address

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv6/address"

	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.interface.interfacesconfig.interface.ipv6.Reassembly

ip-reassembly feature control.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv6/reassembly"

	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-interface:reassembly": {
    }
}

creates netgate.interface.interfacesconfig.interface.ipv6.Reassembly

ip-reassembly feature control.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv6.Reassembly to be added to list

netgate-interface:enabled
boolean

IPv6 reassembly enabled for interface

netgate-interface:reassembly-type
string (netgate.interface.ReassemblyType)
Enum: "full" "virtual"

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:enabled": true,
  • "netgate-interface:reassembly-type": "full"
}

creates or updates netgate.interface.interfacesconfig.interface.ipv6.Reassembly

ip-reassembly feature control.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv6.Reassembly to be added or updated

object (netgate.interface.interfacesconfig.interface.ipv6.Reassembly)

ip-reassembly feature control.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.ipv6.Reassembly

ip-reassembly feature control.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv6/reassembly"

	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.interface.interfacesconfig.interface.ipv6.Tcp

IPv6 TCP configuration values.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv6/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-interface:tcp": {
    }
}

creates netgate.interface.interfacesconfig.interface.ipv6.Tcp

IPv6 TCP configuration values.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv6.Tcp to be added to list

object (netgate.interface.interfacesconfig.interface.ipv6.tcp.Mss)

IPv6 TCP Maximum Segment Size values.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.interface.ipv6.Tcp

IPv6 TCP configuration values.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv6.Tcp to be added or updated

object (netgate.interface.interfacesconfig.interface.ipv6.Tcp)

IPv6 TCP configuration values.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.ipv6.Tcp

IPv6 TCP configuration values.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv6/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.interface.interfacesconfig.interface.ipv6.tcp.Mss

IPv6 TCP Maximum Segment Size values.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv6/tcp/mss"

	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-interface:mss": {
    }
}

creates netgate.interface.interfacesconfig.interface.ipv6.tcp.Mss

IPv6 TCP Maximum Segment Size values.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv6.tcp.Mss to be added to list

netgate-interface:directions
string (netgate.interface.MssClampDirection)
Enum: "Tx" "Rx" "TxRx"
netgate-interface:value
integer <int32>

The IPv4 TCP maximum segment size.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:directions": "Tx",
  • "netgate-interface:value": 0
}

creates or updates netgate.interface.interfacesconfig.interface.ipv6.tcp.Mss

IPv6 TCP Maximum Segment Size values.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.ipv6.tcp.Mss to be added or updated

object (netgate.interface.interfacesconfig.interface.ipv6.tcp.Mss)

IPv6 TCP Maximum Segment Size values.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.ipv6.tcp.Mss

IPv6 TCP Maximum Segment Size values.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/ipv6/tcp/mss"

	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.interface.interfacesconfig.interface.Lldp

returns netgate.interface.interfacesconfig.interface.Lldp

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/lldp"

	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-interface:lldp": {
    }
}

creates netgate.interface.interfacesconfig.interface.Lldp

creates netgate.interface.interfacesconfig.interface.Lldp

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Lldp to be added to list

object (netgate.interface.interfacesconfig.interface.lldp.Management)
netgate-interface:port-name
string

Port name used in LLDP packet.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:management": {
    },
  • "netgate-interface:port-name": "string"
}

creates or updates netgate.interface.interfacesconfig.interface.Lldp

creates or updates netgate.interface.interfacesconfig.interface.Lldp

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Lldp to be added or updated

object (netgate.interface.interfacesconfig.interface.Lldp)

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.Lldp

removes netgate.interface.interfacesconfig.interface.Lldp

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/lldp"

	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.interface.interfacesconfig.interface.lldp.Management

returns netgate.interface.interfacesconfig.interface.lldp.Management

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/lldp/management"

	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-interface:management": {
    }
}

creates netgate.interface.interfacesconfig.interface.lldp.Management

creates netgate.interface.interfacesconfig.interface.lldp.Management

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.lldp.Management to be added to list

netgate-interface:ipv4-address
string

IPv4 management address.

netgate-interface:oid
string

Management object ID.

netgate-interface:ipv6-address
string

IPv6 management address.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:ipv4-address": "string",
  • "netgate-interface:oid": "string",
  • "netgate-interface:ipv6-address": "string"
}

creates or updates netgate.interface.interfacesconfig.interface.lldp.Management

creates or updates netgate.interface.interfacesconfig.interface.lldp.Management

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.lldp.Management to be added or updated

object (netgate.interface.interfacesconfig.interface.lldp.Management)

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.lldp.Management

removes netgate.interface.interfacesconfig.interface.lldp.Management

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/lldp/management"

	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.interface.interfacesconfig.interface.Map

Per-interface parameters for MAP-E and MAP-T.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/map"

	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-interface:map": {
    }
}

creates netgate.interface.interfacesconfig.interface.Map

Per-interface parameters for MAP-E and MAP-T.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Map to be added to list

netgate-interface:is-translation
boolean

If true, this interface is performing MAP-T translations. If false, this interface is performing encapsuations. Valid only when also enabled.

netgate-interface:enabled
boolean

If true, MAP-E encapsulation or MAP-T translations are enabled on this interface.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:is-translation": true,
  • "netgate-interface:enabled": true
}

creates or updates netgate.interface.interfacesconfig.interface.Map

Per-interface parameters for MAP-E and MAP-T.

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.Map to be added or updated

object (netgate.interface.interfacesconfig.interface.Map)

Per-interface parameters for MAP-E and MAP-T.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.Map

Per-interface parameters for MAP-E and MAP-T.

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/map"

	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.interface.interfacesconfig.interface.VlanTagRewrite

returns netgate.interface.interfacesconfig.interface.VlanTagRewrite

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/vlan-tag-rewrite"

	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-interface:vlan-tag-rewrite": {
    }
}

creates netgate.interface.interfacesconfig.interface.VlanTagRewrite

creates netgate.interface.interfacesconfig.interface.VlanTagRewrite

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.VlanTagRewrite to be added to list

netgate-interface:push-dot1q
boolean
Default: false

If true the first pushed tag is of type dot1q, otherwise it will be of type dot1ad.

netgate-interface:tag1
integer <int64>

The first pushed tag value.

netgate-interface:operation
string (netgate.interface.IntfTagRewriteOp)
Enum: "disable" "pop-1" "pop-2" "push-1" "push-2" "translate-1-1" "translate-1-2" "translate-2-1" "translate-2-2"
netgate-interface:tag2
integer <int64>

The second pushed tag value.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:push-dot1q": false,
  • "netgate-interface:tag1": 0,
  • "netgate-interface:operation": "disable",
  • "netgate-interface:tag2": 0
}

creates or updates netgate.interface.interfacesconfig.interface.VlanTagRewrite

creates or updates netgate.interface.interfacesconfig.interface.VlanTagRewrite

path Parameters
name
required
string

Id of interface

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.interface.VlanTagRewrite to be added or updated

object (netgate.interface.interfacesconfig.interface.VlanTagRewrite)

Responses

Request samples

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

removes netgate.interface.interfacesconfig.interface.VlanTagRewrite

removes netgate.interface.interfacesconfig.interface.VlanTagRewrite

path Parameters
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-interface:interfaces-config/interface=%7Bname%7D/vlan-tag-rewrite"

	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.interface.interfacesconfig.LoopbackTable

Loopback name table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/loopback-table"

	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-interface:loopback-table": {
    }
}

creates netgate.interface.interfacesconfig.LoopbackTable

Loopback name table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.LoopbackTable to be added to list

Array of objects (netgate.interface.interfacesconfig.loopbacktable.Loopback)

Loopback name.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.LoopbackTable

Loopback name table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.LoopbackTable to be added or updated

object (netgate.interface.interfacesconfig.LoopbackTable)

Loopback name table.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.LoopbackTable

Loopback name table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/loopback-table"

	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.interface.interfacesconfig.loopbacktable.Loopback

Loopback name.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.loopbacktable.Loopback to be added to list

netgate-interface:name
string

The identifier. A unique name for this Loopback entry.

netgate-interface:mac-address
string

The MAC address for the interface.

netgate-interface:description
string

A user description of the Loopback.

netgate-interface:instance
integer <int32>

Each Loopback creates an interface. The interface will be named 'loopback', where the is the instance number. The instance number must be unique across all Loopback interfaces.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:name": "string",
  • "netgate-interface:mac-address": "string",
  • "netgate-interface:description": "string",
  • "netgate-interface:instance": 0
}

returns netgate.interface.interfacesconfig.loopbacktable.Loopback

Loopback name.

path Parameters
name
required
string

Id of loopback

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/loopback-table/loopback=%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-interface:loopback": {
    }
}

creates or updates netgate.interface.interfacesconfig.loopbacktable.Loopback

Loopback name.

path Parameters
name
required
string

Id of loopback

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.loopbacktable.Loopback to be added or updated

object (netgate.interface.interfacesconfig.loopbacktable.Loopback)

Loopback name.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.loopbacktable.Loopback

Loopback name.

path Parameters
name
required
string

Id of loopback

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/loopback-table/loopback=%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.interface.interfacesconfig.MemifTable

Host memif interface configuration table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/memif-table"

	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-interface:memif-table": {
    }
}

creates netgate.interface.interfacesconfig.MemifTable

Host memif interface configuration table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.MemifTable to be added to list

Array of objects (netgate.interface.interfacesconfig.memiftable.MemifEntry)

A unique 32-bit integer identifying this interface.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.MemifTable

Host memif interface configuration table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.MemifTable to be added or updated

object (netgate.interface.interfacesconfig.MemifTable)

Host memif interface configuration table.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.MemifTable

Host memif interface configuration table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/memif-table"

	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.interface.interfacesconfig.memiftable.MemifEntry

A unique 32-bit integer identifying this interface.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.memiftable.MemifEntry to be added to list

netgate-interface:mode
string

Should be 'ethernet', 'IP' or 'punt/inject'.

netgate-interface:mac-address
string

The MAC address for the interface.

netgate-interface:socket-id
integer <int64>

The socket-id of the socket filename to use in establishing a connection.

object (netgate.interface.interfacesconfig.memiftable.memifentry.Client)
netgate-interface:buffer-size
integer <int64>

The size of the buffer allocated for each ring entry. Default 2048.

netgate-interface:memif-id
integer <int64>

This is the user assigned id of the memif interface.

netgate-interface:secret
string

The secret is used to match and authenticate the other end of the connection.

netgate-interface:ring-size
integer <int32>

The number of entries in the rx/tx rings. The number of entries must be a power of 2 This number is that power of 2, between 8 and 32. The default is 10, for 1024 entries.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:mode": "string",
  • "netgate-interface:mac-address": "string",
  • "netgate-interface:socket-id": 0,
  • "netgate-interface:client": {
    },
  • "netgate-interface:buffer-size": 0,
  • "netgate-interface:memif-id": 0,
  • "netgate-interface:secret": "string",
  • "netgate-interface:ring-size": 0
}

returns netgate.interface.interfacesconfig.memiftable.MemifEntry

A unique 32-bit integer identifying this interface.

path Parameters
socket-id
required
integer <int64>

Id of memif-entry

memif-id
required
integer <int64>

Id of memif-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/memif-table/memif-entry=%7Bsocket-id%7D,%7Bmemif-id%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-interface:memif-entry": {
    }
}

creates or updates netgate.interface.interfacesconfig.memiftable.MemifEntry

A unique 32-bit integer identifying this interface.

path Parameters
socket-id
required
integer <int64>

Id of memif-entry

memif-id
required
integer <int64>

Id of memif-entry

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.memiftable.MemifEntry to be added or updated

object (netgate.interface.interfacesconfig.memiftable.MemifEntry)

A unique 32-bit integer identifying this interface.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.memiftable.MemifEntry

A unique 32-bit integer identifying this interface.

path Parameters
socket-id
required
integer <int64>

Id of memif-entry

memif-id
required
integer <int64>

Id of memif-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/memif-table/memif-entry=%7Bsocket-id%7D,%7Bmemif-id%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.interface.interfacesconfig.memiftable.memifentry.Client

returns netgate.interface.interfacesconfig.memiftable.memifentry.Client

path Parameters
socket-id
required
integer <int64>

Id of memif-entry

memif-id
required
integer <int64>

Id of memif-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/memif-table/memif-entry=%7Bsocket-id%7D,%7Bmemif-id%7D/client"

	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-interface:client": {
    }
}

creates netgate.interface.interfacesconfig.memiftable.memifentry.Client

creates netgate.interface.interfacesconfig.memiftable.memifentry.Client

path Parameters
socket-id
required
integer <int64>

Id of memif-entry

memif-id
required
integer <int64>

Id of memif-entry

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.memiftable.memifentry.Client to be added to list

netgate-interface:tx-queues
integer <int32>

The number of slave tx queues.

netgate-interface:rx-queues
integer <int32>

The number of slave rx queues.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:tx-queues": 0,
  • "netgate-interface:rx-queues": 0
}

creates or updates netgate.interface.interfacesconfig.memiftable.memifentry.Client

creates or updates netgate.interface.interfacesconfig.memiftable.memifentry.Client

path Parameters
socket-id
required
integer <int64>

Id of memif-entry

memif-id
required
integer <int64>

Id of memif-entry

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.memiftable.memifentry.Client to be added or updated

object (netgate.interface.interfacesconfig.memiftable.memifentry.Client)

Responses

Request samples

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

removes netgate.interface.interfacesconfig.memiftable.memifentry.Client

removes netgate.interface.interfacesconfig.memiftable.memifentry.Client

path Parameters
socket-id
required
integer <int64>

Id of memif-entry

memif-id
required
integer <int64>

Id of memif-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/memif-table/memif-entry=%7Bsocket-id%7D,%7Bmemif-id%7D/client"

	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.interface.interfacesconfig.SocketTable

Host memif socket table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/socket-table"

	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-interface:socket-table": {
    }
}

creates netgate.interface.interfacesconfig.SocketTable

Host memif socket table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.SocketTable to be added to list

Array of objects (netgate.interface.interfacesconfig.sockettable.Socket)

A unique 32-bit integer identifying this socket filename.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.SocketTable

Host memif socket table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.SocketTable to be added or updated

object (netgate.interface.interfacesconfig.SocketTable)

Host memif socket table.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.SocketTable

Host memif socket table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/socket-table"

	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.interface.interfacesconfig.sockettable.Socket

A unique 32-bit integer identifying this socket filename.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.sockettable.Socket to be added to list

netgate-interface:filename
string

The path to a socket file used for establishing memif connections. A socket can be used for either server or client interfaces, but not both. A socket can have more than one server using it, or it can have more than one client using it.

netgate-interface:id
integer <int64>

This is the user assigned id of the socket filename.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:filename": "string",
  • "netgate-interface:id": 0
}

returns netgate.interface.interfacesconfig.sockettable.Socket

A unique 32-bit integer identifying this socket filename.

path Parameters
id
required
integer <int64>

Id of socket

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/socket-table/socket=%7Bid%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-interface:socket": {
    }
}

creates or updates netgate.interface.interfacesconfig.sockettable.Socket

A unique 32-bit integer identifying this socket filename.

path Parameters
id
required
integer <int64>

Id of socket

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.sockettable.Socket to be added or updated

object (netgate.interface.interfacesconfig.sockettable.Socket)

A unique 32-bit integer identifying this socket filename.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.sockettable.Socket

A unique 32-bit integer identifying this socket filename.

path Parameters
id
required
integer <int64>

Id of socket

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/socket-table/socket=%7Bid%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.interface.interfacesconfig.Subinterfaces

An interface may have subinterfaces.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/subinterfaces"

	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-interface:subinterfaces": {
    }
}

creates netgate.interface.interfacesconfig.Subinterfaces

An interface may have subinterfaces.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.Subinterfaces to be added to list

Array of objects (netgate.interface.interfacesconfig.subinterfaces.SubifEntry)

Each subinterface entry represents a VLAN.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.Subinterfaces

An interface may have subinterfaces.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.Subinterfaces to be added or updated

object (netgate.interface.interfacesconfig.Subinterfaces)

An interface may have subinterfaces.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.Subinterfaces

An interface may have subinterfaces.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/subinterfaces"

	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.interface.interfacesconfig.subinterfaces.SubifEntry

Each subinterface entry represents a VLAN.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.subinterfaces.SubifEntry to be added to list

netgate-interface:subid
integer <int64>

The subinterface id. It is often also the (outer) VLAN tag value, though they can be different.

object (netgate.interface.interfacesconfig.subinterfaces.subifentry.Vlan)

These fields all contribute to the subinterface definition for VLAN handling.

netgate-interface:if-name
string

The interface on which this subinterface exists.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:subid": 0,
  • "netgate-interface:vlan": {
    },
  • "netgate-interface:if-name": "string"
}

returns netgate.interface.interfacesconfig.subinterfaces.SubifEntry

Each subinterface entry represents a VLAN.

path Parameters
if-name
required
string

Id of subif-entry

subid
required
integer <int64>

Id of subif-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/subinterfaces/subif-entry=%7Bif-name%7D,%7Bsubid%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-interface:subif-entry": {
    }
}

creates or updates netgate.interface.interfacesconfig.subinterfaces.SubifEntry

Each subinterface entry represents a VLAN.

path Parameters
if-name
required
string

Id of subif-entry

subid
required
integer <int64>

Id of subif-entry

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.subinterfaces.SubifEntry to be added or updated

object (netgate.interface.interfacesconfig.subinterfaces.SubifEntry)

Each subinterface entry represents a VLAN.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.subinterfaces.SubifEntry

Each subinterface entry represents a VLAN.

path Parameters
if-name
required
string

Id of subif-entry

subid
required
integer <int64>

Id of subif-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/subinterfaces/subif-entry=%7Bif-name%7D,%7Bsubid%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.interface.interfacesconfig.subinterfaces.subifentry.Vlan

These fields all contribute to the subinterface definition for VLAN handling.

path Parameters
if-name
required
string

Id of subif-entry

subid
required
integer <int64>

Id of subif-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/subinterfaces/subif-entry=%7Bif-name%7D,%7Bsubid%7D/vlan"

	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-interface:vlan": {
    }
}

creates netgate.interface.interfacesconfig.subinterfaces.subifentry.Vlan

These fields all contribute to the subinterface definition for VLAN handling.

path Parameters
if-name
required
string

Id of subif-entry

subid
required
integer <int64>

Id of subif-entry

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.subinterfaces.subifentry.Vlan to be added to list

netgate-interface:exact-match
boolean

By default matching is non-exact. If this value is true, matching is exact.

netgate-interface:default-subif
boolean

The default subinterface is associated with a packet that did not match any other configured subinterface on this interface.

netgate-interface:inner-vlan-id
string

The inner vlan tag id. It can be an integer between 1 and 4095 inclusive, or the word 'any'.

netgate-interface:dot1ad
boolean

By default the outer tag is dot1q. If this value is true, it is instead dot1ad.

netgate-interface:outer-vlan-id
integer <int32>

The outer vlan tag id. It can be an integer between 1 and 4095 inclusive.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:exact-match": true,
  • "netgate-interface:default-subif": true,
  • "netgate-interface:inner-vlan-id": "string",
  • "netgate-interface:dot1ad": true,
  • "netgate-interface:outer-vlan-id": 0
}

creates or updates netgate.interface.interfacesconfig.subinterfaces.subifentry.Vlan

These fields all contribute to the subinterface definition for VLAN handling.

path Parameters
if-name
required
string

Id of subif-entry

subid
required
integer <int64>

Id of subif-entry

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.subinterfaces.subifentry.Vlan to be added or updated

object (netgate.interface.interfacesconfig.subinterfaces.subifentry.Vlan)

These fields all contribute to the subinterface definition for VLAN handling.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.subinterfaces.subifentry.Vlan

These fields all contribute to the subinterface definition for VLAN handling.

path Parameters
if-name
required
string

Id of subif-entry

subid
required
integer <int64>

Id of subif-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/subinterfaces/subif-entry=%7Bif-name%7D,%7Bsubid%7D/vlan"

	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.interface.interfacesconfig.TapTable

Host Tap interface configuration table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/tap-table"

	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-interface:tap-table": {
    }
}

creates netgate.interface.interfacesconfig.TapTable

Host Tap interface configuration table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.TapTable to be added to list

Array of objects (netgate.interface.interfacesconfig.taptable.Tap)

Unique identifing host tap name.

Responses

Request samples

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

creates or updates netgate.interface.interfacesconfig.TapTable

Host Tap interface configuration table.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.TapTable to be added or updated

object (netgate.interface.interfacesconfig.TapTable)

Host Tap interface configuration table.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.TapTable

Host Tap interface configuration table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/tap-table"

	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.interface.interfacesconfig.taptable.Tap

Unique identifing host tap name.

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.taptable.Tap to be added to list

netgate-interface:mac-address
string

The MAC address of the interface.

netgate-interface:host-namespace
string (netgate.interface.HostNamespace)
Enum: "host" "dataplane"
netgate-interface:instance
integer <int64>

The tap instance number.

netgate-interface:tx-ring-size
integer <int32>

A power of 2 between 0 and 15 inclusive yielding a transmit ring size 32 to 32768 entries. The default is 8 (256 entries).

netgate-interface:host-ipv6-prefix
string

The IPv6 prefix on the interface.

netgate-interface:host-ipv4-gateway
string

The IPv4 gateway address on the interface.

netgate-interface:host-mac-address
string

The MAC address of the host tap interface.

netgate-interface:host-ipv4-prefix
string

The IPv4 prefix on the interface.

netgate-interface:rx-ring-size
integer <int32>

A power of 2 between 0 and 15 inclusive yielding a receive ring size 32 to 32768 entries. The default is 8 (256 entries).

netgate-interface:host-name
string

The name of the tap on the host system.

netgate-interface:host-ipv6-gateway
string

The IPv6 gateway address on the interface.

netgate-interface:host-bridge
string

The host bridge to which the tap will be attached.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-interface:mac-address": "string",
  • "netgate-interface:host-namespace": "host",
  • "netgate-interface:instance": 0,
  • "netgate-interface:tx-ring-size": 0,
  • "netgate-interface:host-ipv6-prefix": "string",
  • "netgate-interface:host-ipv4-gateway": "string",
  • "netgate-interface:host-mac-address": "string",
  • "netgate-interface:host-ipv4-prefix": "string",
  • "netgate-interface:rx-ring-size": 0,
  • "netgate-interface:host-name": "string",
  • "netgate-interface:host-ipv6-gateway": "string",
  • "netgate-interface:host-bridge": "string"
}

returns netgate.interface.interfacesconfig.taptable.Tap

Unique identifing host tap name.

path Parameters
host-name
required
string

Id of tap

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/tap-table/tap=%7Bhost-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-interface:tap": {
    }
}

creates or updates netgate.interface.interfacesconfig.taptable.Tap

Unique identifing host tap name.

path Parameters
host-name
required
string

Id of tap

Request Body schema: application/yang-data+json

netgate.interface.interfacesconfig.taptable.Tap to be added or updated

object (netgate.interface.interfacesconfig.taptable.Tap)

Unique identifing host tap name.

Responses

Request samples

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

removes netgate.interface.interfacesconfig.taptable.Tap

Unique identifing host tap name.

path Parameters
host-name
required
string

Id of tap

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-config/tap-table/tap=%7Bhost-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))

}

interfaces-state

returns netgate.interface.InterfacesState

Interface state information.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-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-interface:interfaces-state": {
    }
}

returns netgate.interface.interfacesstate.BondTable

Bond interface state table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/bond-table"

	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-interface:bond-table": {
    }
}

returns netgate.interface.interfacesstate.bondtable.Bond

Bond interface.

path Parameters
instance
required
integer <int64>

Id of bond

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/bond-table/bond=%7Binstance%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-interface:bond": {
    }
}

returns netgate.interface.interfacesstate.bondtable.bond.SlaveIfTable

The list of slave interfaces.

path Parameters
instance
required
integer <int64>

Id of bond

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/bond-table/bond=%7Binstance%7D/slave-if-table"

	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-interface:slave-if-table": {
    }
}

returns netgate.interface.interfacesstate.bondtable.bond.slaveiftable.SlaveIf

Slave interface.

path Parameters
instance
required
integer <int64>

Id of bond

if-name
required
string

Id of slave-if

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/bond-table/bond=%7Binstance%7D/slave-if-table/slave-if=%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-interface:slave-if": {
    }
}

returns netgate.interface.interfacesstate.BridgeTable

Bridge mapping table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/bridge-table"

	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-interface:bridge-table": {
    }
}

returns netgate.interface.interfacesstate.bridgetable.BridgeEntry

Bridge Domain Id.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/bridge-table/bridge-entry=%7Bbdi%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-interface:bridge-entry": {
    }
}

returns netgate.interface.interfacesstate.bridgetable.bridgeentry.BridgeArpTable

Bridge ARP Entry Table.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/bridge-table/bridge-entry=%7Bbdi%7D/bridge-arp-table"

	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-interface:bridge-arp-table": {
    }
}

returns netgate.interface.interfacesstate.bridgetable.bridgeentry.bridgearptable.BridgeArpEntry

Bridge ARP entry table.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

ip-address
required
string

Id of bridge-arp-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/bridge-table/bridge-entry=%7Bbdi%7D/bridge-arp-table/bridge-arp-entry=%7Bip-address%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-interface:bridge-arp-entry": {
    }
}

returns netgate.interface.interfacesstate.bridgetable.bridgeentry.DomainIfMembers

Bridge Domain Interface Members.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/bridge-table/bridge-entry=%7Bbdi%7D/domain-if-members"

	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-interface:domain-if-members": {
    }
}

returns netgate.interface.interfacesstate.bridgetable.bridgeentry.domainifmembers.DomainIf

Bridge domain interface members.

path Parameters
bdi
required
integer <int64>

Id of bridge-entry

if-name
required
string

Id of domain-if

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/bridge-table/bridge-entry=%7Bbdi%7D/domain-if-members/domain-if=%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-interface:domain-if": {
    }
}

returns netgate.interface.interfacesstate.Interface

The list of interfaces on the device.

path Parameters
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-interface:interfaces-state/interface=%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-interface:interface": {
    }
}

returns netgate.interface.interfacesstate.interface.AccessList

If the interface has any Access Control Lists, they are listed here in two groups: those that apply to packet ingress and those that apply to egresss. The two sets of ACLs are sorted independenty and applied in ascending sequence-number order.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/access-list"

	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-interface:access-list": {
    }
}

returns netgate.interface.interfacesstate.interface.accesslist.Input

These are the ACL rule-sets that apply to ingress packets.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/access-list/input"

	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-interface:input": {
    }
}

returns netgate.interface.interfacesstate.interface.accesslist.input.AclList

Each ACL rule-set can appear at most once within the input list.

path Parameters
name
required
string

Id of interface

sequence
required
integer <int64>

Id of acl-list

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/interface=%7Bname%7D/access-list/input/acl-list=%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-interface:acl-list": {
    }
}

returns netgate.interface.interfacesstate.interface.accesslist.Macip

An interface may also have at most one ACL based upon a combination of MAC address and IP. If that ACL is present, it is always on the ingress packets.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/access-list/macip"

	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-interface:macip": {
    }
}

returns netgate.interface.interfacesstate.interface.accesslist.Output

These are the ACL rule-sets that apply to egress packets.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/access-list/output"

	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-interface:output": {
    }
}

returns netgate.interface.interfacesstate.interface.accesslist.output.AclList

Each ACL rule-set can appear at most once within the output list.

path Parameters
name
required
string

Id of interface

sequence
required
integer <int64>

Id of acl-list

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/interface=%7Bname%7D/access-list/output/acl-list=%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-interface:acl-list": {
    }
}

returns netgate.interface.interfacesstate.interface.Bond

If the interface is being used as a slave, this node contains the corresponding bond interface.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/bond"

	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-interface:bond": {
    }
}

returns netgate.interface.interfacesstate.interface.Counters

Per-interface counters from VPP.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/counters"

	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-interface:counters": {
    }
}

returns netgate.interface.interfacesstate.interface.Ipv4

IPv4 address family state information.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/ipv4"

	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-interface:ipv4": {
    }
}

returns netgate.interface.interfacesstate.interface.ipv4.Address

returns netgate.interface.interfacesstate.interface.ipv4.Address

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/ipv4/address"

	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-interface:address": {
    }
}

returns netgate.interface.interfacesstate.interface.ipv4.Tcp

IPv4 TCP values.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/ipv4/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-interface:tcp": {
    }
}

returns netgate.interface.interfacesstate.interface.ipv4.tcp.Mss

IPv4 TCP Maximum Segment Size values.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/ipv4/tcp/mss"

	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-interface:mss": {
    }
}

returns netgate.interface.interfacesstate.interface.Ipv6

IPv6 address family state information.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/ipv6"

	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-interface:ipv6": {
    }
}

returns netgate.interface.interfacesstate.interface.ipv6.Address

returns netgate.interface.interfacesstate.interface.ipv6.Address

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/ipv6/address"

	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-interface:address": {
    }
}

returns netgate.interface.interfacesstate.interface.ipv6.Tcp

IPv6 TCP values.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/ipv6/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-interface:tcp": {
    }
}

returns netgate.interface.interfacesstate.interface.ipv6.tcp.Mss

IPv6 TCP Maximum Segment Size values.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/ipv6/tcp/mss"

	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-interface:mss": {
    }
}

returns netgate.interface.interfacesstate.interface.SlaveIfTable

If the interface is a bond interface, this node contains the list of its slave interfaces.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/slave-if-table"

	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-interface:slave-if-table": {
    }
}

returns netgate.interface.interfacesstate.interface.slaveiftable.SlaveIf

Slave interface.

path Parameters
name
required
string

Id of interface

if-name
required
string

Id of slave-if

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/interface=%7Bname%7D/slave-if-table/slave-if=%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-interface:slave-if": {
    }
}

returns netgate.interface.interfacesstate.interface.Subif

These fields all contribute to the subinterface definition for VLAN handling.

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/subif"

	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-interface:subif": {
    }
}

returns netgate.interface.interfacesstate.interface.VlanTagRewrite

returns netgate.interface.interfacesstate.interface.VlanTagRewrite

path Parameters
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-interface:interfaces-state/interface=%7Bname%7D/vlan-tag-rewrite"

	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-interface:vlan-tag-rewrite": {
    }
}

returns netgate.interface.interfacesstate.LacpTable

Link Aggregation Control Protocol (LACP) state table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/lacp-table"

	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-interface:lacp-table": {
    }
}

returns netgate.interface.interfacesstate.lacptable.LacpEntry

LACP entry.

path Parameters
slave-if-name
required
string

Id of lacp-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/lacp-table/lacp-entry=%7Bslave-if-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-interface:lacp-entry": {
    }
}

returns netgate.interface.interfacesstate.lacptable.lacpentry.Actor

The actor parameters.

path Parameters
slave-if-name
required
string

Id of lacp-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/lacp-table/lacp-entry=%7Bslave-if-name%7D/actor"

	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-interface:actor": {
    }
}

returns netgate.interface.interfacesstate.lacptable.lacpentry.Partner

The partner parameters.

path Parameters
slave-if-name
required
string

Id of lacp-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/lacp-table/lacp-entry=%7Bslave-if-name%7D/partner"

	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-interface:partner": {
    }
}

returns netgate.interface.interfacesstate.LoopbackTable

Loopback name table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/loopback-table"

	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-interface:loopback-table": {
    }
}

returns netgate.interface.interfacesstate.loopbacktable.Loopback

Loopback name.

path Parameters
name
required
string

Id of loopback

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/loopback-table/loopback=%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-interface:loopback": {
    }
}

returns netgate.interface.interfacesstate.MemifTable

Host memif interface state table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/memif-table"

	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-interface:memif-table": {
    }
}

returns netgate.interface.interfacesstate.memiftable.MemifEntry

A unique 32-bit integer identifying this interface.

path Parameters
socket-id
required
integer <int64>

Id of memif-entry

memif-id
required
integer <int64>

Id of memif-entry

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/memif-table/memif-entry=%7Bsocket-id%7D,%7Bmemif-id%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-interface:memif-entry": {
    }
}

returns netgate.interface.interfacesstate.SocketTable

Host memif socket table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/socket-table"

	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-interface:socket-table": {
    }
}

returns netgate.interface.interfacesstate.sockettable.Socket

A unique 32-bit integer identifying this socket filename.

path Parameters
id
required
integer <int64>

Id of socket

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/socket-table/socket=%7Bid%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-interface:socket": {
    }
}

returns netgate.interface.interfacesstate.TapTable

Host Tap table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/tap-table"

	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-interface:tap-table": {
    }
}

returns netgate.interface.interfacesstate.taptable.Tap

Unique identifing host tap name.

path Parameters
host-name
required
string

Id of tap

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-interface:interfaces-state/tap-table/tap=%7Bhost-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-interface:tap": {
    }
}

clear-interface-counters

operates on netgate.interface.ClearInterfaceCounters

operates on netgate.interface.ClearInterfaceCounters

Request Body schema: application/yang-data+json
object (netgate.interface.clearinterfacecounters.Input)

Responses

Request samples

Content type
application/yang-data+json
{
  • "input": {
    }
}

packet-counters

/operations/netgate-interface:packet-counters

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/operations/netgate-interface:packet-counters"

	req, _ := http.NewRequest("POST", 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
{
  • "output": {
    }
}