Netgate TNSR Logo
API docs by Redocly

netgate-map API (25.10)

This YANG module provides a Netgate-defined data-model for Mapping Address and Port (MAP) data.

Copyright 2018-2022, 2025 Rubicon Communications, LLC.

nat64-config

returns netgate.map.Nat64Config

returns netgate.map.Nat64Config

Responses

Request samples 

package main

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

func main() {

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

creates netgate.map.Nat64Config

creates netgate.map.Nat64Config

Request Body schema: application/yang-data+json

netgate.map.Nat64Config to be added to list

object (netgate.map.nat64config.Map)

Configuration for MAP-E and MAP-t translations.

Responses

Request samples

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

creates or updates netgate.map.Nat64Config

creates or updates netgate.map.Nat64Config

Request Body schema: application/yang-data+json

netgate.map.Nat64Config to be added or updated

object (netgate.map.Nat64Config)

Responses

Request samples

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

removes netgate.map.Nat64Config

removes netgate.map.Nat64Config

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-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.map.nat64config.Map

Configuration for MAP-E and MAP-t translations.

Responses

Request samples 

package main

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

func main() {

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

creates netgate.map.nat64config.Map

Configuration for MAP-E and MAP-t translations.

Request Body schema: application/yang-data+json

netgate.map.nat64config.Map to be added to list

object (netgate.map.nat64config.map.Parameters)

Global MAP parameters.

object (netgate.map.nat64config.map.MapDomains)

MAP table.

Responses

Request samples

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

creates or updates netgate.map.nat64config.Map

Configuration for MAP-E and MAP-t translations.

Request Body schema: application/yang-data+json

netgate.map.nat64config.Map to be added or updated

object (netgate.map.nat64config.Map)

Configuration for MAP-E and MAP-t translations.

Responses

Request samples

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

removes netgate.map.nat64config.Map

Configuration for MAP-E and MAP-t translations.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/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.map.nat64config.map.MapDomains

MAP table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/map-domains"

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

creates netgate.map.nat64config.map.MapDomains

MAP table.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.MapDomains to be added to list

Array of objects (netgate.map.nat64config.map.mapdomains.Domain)

MAP domain name.

Responses

Request samples

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

creates or updates netgate.map.nat64config.map.MapDomains

MAP table.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.MapDomains to be added or updated

object (netgate.map.nat64config.map.MapDomains)

MAP table.

Responses

Request samples

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

removes netgate.map.nat64config.map.MapDomains

MAP table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/map-domains"

	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.map.nat64config.map.mapdomains.Domain

MAP domain name.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.mapdomains.Domain to be added to list

netgate-map:psid-offset
integer <int32>

The offset of the Port Set Identifier (PSID).

netgate-map:ea-bits-length
integer <int32>

The width of the embedded address field in bits.

netgate-map:ip6-src-prefix
string

The IPv6 Border Relay (BR) address or tunnel source. For MAP-E, this prefix must be a full /128 address. For MAP-T, this prefix must be /96 or /64.

netgate-map:ip4-prefix
string

The Rule IPv4 prefix.

netgate-map:name
string

The unique MAP domain name identifier.

netgate-map:description
string

An arbitrary description of the MAP domain.

object (netgate.map.nat64config.map.mapdomains.domain.Rules)

The set of MAP Rules.

netgate-map:psid-length
integer <int32>

The length of the Port Set Identifier (PSID).

netgate-map:ip6-prefix
string

The Rule IPv6 prefix.

netgate-map:mtu
integer <int32>

MTU

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-map:psid-offset": 0,
  • "netgate-map:ea-bits-length": 0,
  • "netgate-map:ip6-src-prefix": "string",
  • "netgate-map:ip4-prefix": "string",
  • "netgate-map:name": "string",
  • "netgate-map:description": "string",
  • "netgate-map:rules": {
    },
  • "netgate-map:psid-length": 0,
  • "netgate-map:ip6-prefix": "string",
  • "netgate-map:mtu": 0
}

returns netgate.map.nat64config.map.mapdomains.Domain

MAP domain name.

path Parameters
name
required
string

Id of domain

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/map-domains/domain=%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-map:domain": {
    }
}

creates or updates netgate.map.nat64config.map.mapdomains.Domain

MAP domain name.

path Parameters
name
required
string

Id of domain

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.mapdomains.Domain to be added or updated

object (netgate.map.nat64config.map.mapdomains.Domain)

MAP domain name.

Responses

Request samples

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

removes netgate.map.nat64config.map.mapdomains.Domain

MAP domain name.

path Parameters
name
required
string

Id of domain

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/map-domains/domain=%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.map.nat64config.map.mapdomains.domain.Rules

The set of MAP Rules.

path Parameters
name
required
string

Id of domain

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/map-domains/domain=%7Bname%7D/rules"

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

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

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

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

}

Response samples

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

creates netgate.map.nat64config.map.mapdomains.domain.Rules

The set of MAP Rules.

path Parameters
name
required
string

Id of domain

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.mapdomains.domain.Rules to be added to list

Array of objects (netgate.map.nat64config.map.mapdomains.domain.rules.Rule)

Port Set Identifier

Responses

Request samples

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

creates or updates netgate.map.nat64config.map.mapdomains.domain.Rules

The set of MAP Rules.

path Parameters
name
required
string

Id of domain

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.mapdomains.domain.Rules to be added or updated

object (netgate.map.nat64config.map.mapdomains.domain.Rules)

The set of MAP Rules.

Responses

Request samples

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

removes netgate.map.nat64config.map.mapdomains.domain.Rules

The set of MAP Rules.

path Parameters
name
required
string

Id of domain

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/map-domains/domain=%7Bname%7D/rules"

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

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

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

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

}

creates netgate.map.nat64config.map.mapdomains.domain.rules.Rule

Port Set Identifier

path Parameters
name
required
string

Id of domain

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.mapdomains.domain.rules.Rule to be added to list

netgate-map:ip6-destination
string

The destination IPv6 address.

netgate-map:psid
integer <int64>

The PSID in the range [0 .. (1 << psid-length)).

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-map:ip6-destination": "string",
  • "netgate-map:psid": 0
}

returns netgate.map.nat64config.map.mapdomains.domain.rules.Rule

Port Set Identifier

path Parameters
name
required
string

Id of domain

psid
required
integer <int64>

Id of rule

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/map-domains/domain=%7Bname%7D/rules/rule=%7Bpsid%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-map:rule": {
    }
}

creates or updates netgate.map.nat64config.map.mapdomains.domain.rules.Rule

Port Set Identifier

path Parameters
name
required
string

Id of domain

psid
required
integer <int64>

Id of rule

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.mapdomains.domain.rules.Rule to be added or updated

object (netgate.map.nat64config.map.mapdomains.domain.rules.Rule)

Port Set Identifier

Responses

Request samples

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

removes netgate.map.nat64config.map.mapdomains.domain.rules.Rule

Port Set Identifier

path Parameters
name
required
string

Id of domain

psid
required
integer <int64>

Id of rule

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/map-domains/domain=%7Bname%7D/rules/rule=%7Bpsid%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.map.nat64config.map.Parameters

Global MAP parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters"

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

creates netgate.map.nat64config.map.Parameters

Global MAP parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.Parameters to be added to list

object (netgate.map.nat64config.map.parameters.Tcp)

MAP TCP parameters.

object (netgate.map.nat64config.map.parameters.SecurityCheck)

MAP security-check parameters.

object (netgate.map.nat64config.map.parameters.Fragment)

Parameters that indicate how MAP fragmentation should happen.

object (netgate.map.nat64config.map.parameters.TrafficClass)

MAP traffic-class parameters.

object (netgate.map.nat64config.map.parameters.Icmp)

MAP ICMP parameters.

object (netgate.map.nat64config.map.parameters.PreResolve)

MAP pre-resolved routing parameters.

object (netgate.map.nat64config.map.parameters.Icmp6)

MAP ICMP6 parameters.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-map:tcp": {
    },
  • "netgate-map:security-check": {
    },
  • "netgate-map:fragment": {
    },
  • "netgate-map:traffic-class": {
    },
  • "netgate-map:icmp": {
    },
  • "netgate-map:pre-resolve": {
    },
  • "netgate-map:icmp6": {
    }
}

creates or updates netgate.map.nat64config.map.Parameters

Global MAP parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.Parameters to be added or updated

object (netgate.map.nat64config.map.Parameters)

Global MAP parameters.

Responses

Request samples

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

removes netgate.map.nat64config.map.Parameters

Global MAP parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters"

	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.map.nat64config.map.parameters.Fragment

Parameters that indicate how MAP fragmentation should happen.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/fragment"

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

creates netgate.map.nat64config.map.parameters.Fragment

Parameters that indicate how MAP fragmentation should happen.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.Fragment to be added to list

netgate-map:inner
boolean

If needed, inner packets should be fragmented.

netgate-map:ignore-df
boolean

If true, perform IPv4 fragmentation despite the value of the DF bit.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-map:inner": true,
  • "netgate-map:ignore-df": true
}

creates or updates netgate.map.nat64config.map.parameters.Fragment

Parameters that indicate how MAP fragmentation should happen.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.Fragment to be added or updated

object (netgate.map.nat64config.map.parameters.Fragment)

Parameters that indicate how MAP fragmentation should happen.

Responses

Request samples

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

removes netgate.map.nat64config.map.parameters.Fragment

Parameters that indicate how MAP fragmentation should happen.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/fragment"

	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.map.nat64config.map.parameters.Icmp

MAP ICMP parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/icmp"

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

creates netgate.map.nat64config.map.parameters.Icmp

MAP ICMP parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.Icmp to be added to list

netgate-map:source-address
string

This parameter specifies the ICMP error relay source address.

Responses

Request samples

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

creates or updates netgate.map.nat64config.map.parameters.Icmp

MAP ICMP parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.Icmp to be added or updated

object (netgate.map.nat64config.map.parameters.Icmp)

MAP ICMP parameters.

Responses

Request samples

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

removes netgate.map.nat64config.map.parameters.Icmp

MAP ICMP parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/icmp"

	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.map.nat64config.map.parameters.Icmp6

MAP ICMP6 parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/icmp6"

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

creates netgate.map.nat64config.map.parameters.Icmp6

MAP ICMP6 parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.Icmp6 to be added to list

netgate-map:unreachables
boolean

If true, generate ICMP6 unreachable messages.

Responses

Request samples

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

creates or updates netgate.map.nat64config.map.parameters.Icmp6

MAP ICMP6 parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.Icmp6 to be added or updated

object (netgate.map.nat64config.map.parameters.Icmp6)

MAP ICMP6 parameters.

Responses

Request samples

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

removes netgate.map.nat64config.map.parameters.Icmp6

MAP ICMP6 parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/icmp6"

	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.map.nat64config.map.parameters.PreResolve

MAP pre-resolved routing parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/pre-resolve"

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

creates netgate.map.nat64config.map.parameters.PreResolve

MAP pre-resolved routing parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.PreResolve to be added to list

object (netgate.map.nat64config.map.parameters.preresolve.Ipv4)

IPv4 pre-resolved parameters.

object (netgate.map.nat64config.map.parameters.preresolve.Ipv6)

IPv6 pre-resolved parameters.

Responses

Request samples

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

creates or updates netgate.map.nat64config.map.parameters.PreResolve

MAP pre-resolved routing parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.PreResolve to be added or updated

object (netgate.map.nat64config.map.parameters.PreResolve)

MAP pre-resolved routing parameters.

Responses

Request samples

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

removes netgate.map.nat64config.map.parameters.PreResolve

MAP pre-resolved routing parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/pre-resolve"

	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.map.nat64config.map.parameters.preresolve.Ipv4

IPv4 pre-resolved parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/pre-resolve/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-map:ipv4": {
    }
}

creates netgate.map.nat64config.map.parameters.preresolve.Ipv4

IPv4 pre-resolved parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.preresolve.Ipv4 to be added to list

netgate-map:next-hop
string

Use this IPv4 as the re-resolved next-hop.

Responses

Request samples

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

creates or updates netgate.map.nat64config.map.parameters.preresolve.Ipv4

IPv4 pre-resolved parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.preresolve.Ipv4 to be added or updated

object (netgate.map.nat64config.map.parameters.preresolve.Ipv4)

IPv4 pre-resolved parameters.

Responses

Request samples

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

removes netgate.map.nat64config.map.parameters.preresolve.Ipv4

IPv4 pre-resolved parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/pre-resolve/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.map.nat64config.map.parameters.preresolve.Ipv6

IPv6 pre-resolved parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/pre-resolve/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-map:ipv6": {
    }
}

creates netgate.map.nat64config.map.parameters.preresolve.Ipv6

IPv6 pre-resolved parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.preresolve.Ipv6 to be added to list

netgate-map:next-hop
string

Use this IPv6 as the re-resolved next-hop.

Responses

Request samples

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

creates or updates netgate.map.nat64config.map.parameters.preresolve.Ipv6

IPv6 pre-resolved parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.preresolve.Ipv6 to be added or updated

object (netgate.map.nat64config.map.parameters.preresolve.Ipv6)

IPv6 pre-resolved parameters.

Responses

Request samples

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

removes netgate.map.nat64config.map.parameters.preresolve.Ipv6

IPv6 pre-resolved parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/pre-resolve/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.map.nat64config.map.parameters.SecurityCheck

MAP security-check parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/security-check"

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

creates netgate.map.nat64config.map.parameters.SecurityCheck

MAP security-check parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.SecurityCheck to be added to list

netgate-map:enable
boolean
Default: true

If true, perform security checks on the first inbound packet.

netgate-map:fragments
boolean

If true, also perform security checks on the subsequent inbound fragments too.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-map:enable": true,
  • "netgate-map:fragments": true
}

creates or updates netgate.map.nat64config.map.parameters.SecurityCheck

MAP security-check parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.SecurityCheck to be added or updated

object (netgate.map.nat64config.map.parameters.SecurityCheck)

MAP security-check parameters.

Responses

Request samples

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

removes netgate.map.nat64config.map.parameters.SecurityCheck

MAP security-check parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/security-check"

	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.map.nat64config.map.parameters.Tcp

MAP TCP parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/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-map:tcp": {
    }
}

creates netgate.map.nat64config.map.parameters.Tcp

MAP TCP parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.Tcp to be added to list

netgate-map:mss
integer <int32>

The Maximum Segment Size is the largest amount of data, specified in bytes, that TCP is willing to receive in a single segment.

Responses

Request samples

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

creates or updates netgate.map.nat64config.map.parameters.Tcp

MAP TCP parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.Tcp to be added or updated

object (netgate.map.nat64config.map.parameters.Tcp)

MAP TCP parameters.

Responses

Request samples

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

removes netgate.map.nat64config.map.parameters.Tcp

MAP TCP parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/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.map.nat64config.map.parameters.TrafficClass

MAP traffic-class parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/traffic-class"

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

creates netgate.map.nat64config.map.parameters.TrafficClass

MAP traffic-class parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.TrafficClass to be added to list

netgate-map:copy
boolean

If true, the traffic class/TOS field is copied from the original packet to the encapsulating header. If false, the 'tc' value is encoded instead.

netgate-map:tc
integer <int32>

If the 'copy' field is false, encode this value as the traffic-class/TOS field in encapsulated headers.

Responses

Request samples

Content type
application/yang-data+json
{
  • "netgate-map:copy": true,
  • "netgate-map:tc": 0
}

creates or updates netgate.map.nat64config.map.parameters.TrafficClass

MAP traffic-class parameters.

Request Body schema: application/yang-data+json

netgate.map.nat64config.map.parameters.TrafficClass to be added or updated

object (netgate.map.nat64config.map.parameters.TrafficClass)

MAP traffic-class parameters.

Responses

Request samples

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

removes netgate.map.nat64config.map.parameters.TrafficClass

MAP traffic-class parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-config/map/parameters/traffic-class"

	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))

}

nat64-state

returns netgate.map.Nat64State

returns netgate.map.Nat64State

Responses

Request samples 

package main

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

func main() {

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

creates netgate.map.Nat64State

creates netgate.map.Nat64State

Request Body schema: application/yang-data+json

netgate.map.Nat64State to be added to list

object (netgate.map.nat64state.Map)

State for MAP-E and MAP-t translations.

Responses

Request samples

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

creates or updates netgate.map.Nat64State

creates or updates netgate.map.Nat64State

Request Body schema: application/yang-data+json

netgate.map.Nat64State to be added or updated

object (netgate.map.Nat64State)

Responses

Request samples

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

removes netgate.map.Nat64State

removes netgate.map.Nat64State

Responses

Request samples 

package main

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

func main() {

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

	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.map.nat64state.Map

State for MAP-E and MAP-t translations.

Responses

Request samples 

package main

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

func main() {

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

returns netgate.map.nat64state.map.MapDomains

MAP table.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/map-domains"

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

returns netgate.map.nat64state.map.mapdomains.Domain

MAP domain name.

path Parameters
name
required
string

Id of domain

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/map-domains/domain=%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-map:domain": {
    }
}

returns netgate.map.nat64state.map.mapdomains.domain.Rules

The set of MAP Rules.

path Parameters
name
required
string

Id of domain

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/map-domains/domain=%7Bname%7D/rules"

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

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

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

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

}

Response samples

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

returns netgate.map.nat64state.map.mapdomains.domain.rules.Rule

Port Set Identifier

path Parameters
name
required
string

Id of domain

psid
required
integer <int64>

Id of rule

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/map-domains/domain=%7Bname%7D/rules/rule=%7Bpsid%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-map:rule": {
    }
}

returns netgate.map.nat64state.map.Parameters

Global MAP parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/parameters"

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

returns netgate.map.nat64state.map.parameters.Fragment

Parameters that indicate how MAP fragmentation should happen.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/parameters/fragment"

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

returns netgate.map.nat64state.map.parameters.Icmp

MAP ICMP parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/parameters/icmp"

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

returns netgate.map.nat64state.map.parameters.Icmp6

MAP ICMP6 parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/parameters/icmp6"

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

returns netgate.map.nat64state.map.parameters.PreResolve

MAP pre-resolved routing parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/parameters/pre-resolve"

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

returns netgate.map.nat64state.map.parameters.preresolve.Ipv4

IPv4 pre-resolved parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/parameters/pre-resolve/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-map:ipv4": {
    }
}

returns netgate.map.nat64state.map.parameters.preresolve.Ipv6

IPv6 pre-resolved parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/parameters/pre-resolve/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-map:ipv6": {
    }
}

returns netgate.map.nat64state.map.parameters.SecurityCheck

MAP security-check parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/parameters/security-check"

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

returns netgate.map.nat64state.map.parameters.Tcp

MAP TCP parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/parameters/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-map:tcp": {
    }
}

returns netgate.map.nat64state.map.parameters.TrafficClass

MAP traffic-class parameters.

Responses

Request samples 

package main

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

func main() {

	url := "http://hostname/restconf/data/netgate-map:nat64-state/map/parameters/traffic-class"

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