2016-06-14 16:17:44 +00:00
|
|
|
// Client for UPnP Device Control Protocol Internet Gateway Device v1.
|
|
|
|
//
|
|
|
|
// This DCP is documented in detail at: http://upnp.org/specs/gw/UPnP-gw-InternetGatewayDevice-v1-Device.pdf
|
|
|
|
//
|
|
|
|
// Typically, use one of the New* functions to create clients for services.
|
|
|
|
package internetgateway1
|
|
|
|
|
2019-06-09 07:24:20 +00:00
|
|
|
// ***********************************************************
|
|
|
|
// GENERATED FILE - DO NOT EDIT BY HAND. See README.md
|
|
|
|
// ***********************************************************
|
2016-06-14 16:17:44 +00:00
|
|
|
|
|
|
|
import (
|
2021-10-19 13:43:41 +00:00
|
|
|
"context"
|
2016-06-14 16:17:44 +00:00
|
|
|
"net/url"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/huin/goupnp"
|
|
|
|
"github.com/huin/goupnp/soap"
|
|
|
|
)
|
|
|
|
|
|
|
|
// Hack to avoid Go complaining if time isn't used.
|
|
|
|
var _ time.Time
|
|
|
|
|
|
|
|
// Device URNs:
|
|
|
|
const (
|
|
|
|
URN_LANDevice_1 = "urn:schemas-upnp-org:device:LANDevice:1"
|
|
|
|
URN_WANConnectionDevice_1 = "urn:schemas-upnp-org:device:WANConnectionDevice:1"
|
|
|
|
URN_WANDevice_1 = "urn:schemas-upnp-org:device:WANDevice:1"
|
|
|
|
)
|
|
|
|
|
|
|
|
// Service URNs:
|
|
|
|
const (
|
|
|
|
URN_LANHostConfigManagement_1 = "urn:schemas-upnp-org:service:LANHostConfigManagement:1"
|
|
|
|
URN_Layer3Forwarding_1 = "urn:schemas-upnp-org:service:Layer3Forwarding:1"
|
|
|
|
URN_WANCableLinkConfig_1 = "urn:schemas-upnp-org:service:WANCableLinkConfig:1"
|
|
|
|
URN_WANCommonInterfaceConfig_1 = "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1"
|
|
|
|
URN_WANDSLLinkConfig_1 = "urn:schemas-upnp-org:service:WANDSLLinkConfig:1"
|
|
|
|
URN_WANEthernetLinkConfig_1 = "urn:schemas-upnp-org:service:WANEthernetLinkConfig:1"
|
|
|
|
URN_WANIPConnection_1 = "urn:schemas-upnp-org:service:WANIPConnection:1"
|
|
|
|
URN_WANPOTSLinkConfig_1 = "urn:schemas-upnp-org:service:WANPOTSLinkConfig:1"
|
|
|
|
URN_WANPPPConnection_1 = "urn:schemas-upnp-org:service:WANPPPConnection:1"
|
|
|
|
)
|
|
|
|
|
|
|
|
// LANHostConfigManagement1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:LANHostConfigManagement:1". See
|
|
|
|
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
|
|
|
|
// are provided for informational value.
|
|
|
|
type LANHostConfigManagement1 struct {
|
|
|
|
goupnp.ServiceClient
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewLANHostConfigManagement1Clients discovers instances of the service on the network,
|
|
|
|
// and returns clients to any that are found. errors will contain an error for
|
|
|
|
// any devices that replied but which could not be queried, and err will be set
|
|
|
|
// if the discovery process failed outright.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package.
|
|
|
|
func NewLANHostConfigManagement1Clients() (clients []*LANHostConfigManagement1, errors []error, err error) {
|
|
|
|
var genericClients []goupnp.ServiceClient
|
|
|
|
if genericClients, errors, err = goupnp.NewServiceClients(URN_LANHostConfigManagement_1); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
clients = newLANHostConfigManagement1ClientsFromGenericClients(genericClients)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewLANHostConfigManagement1ClientsByURL discovers instances of the service at the given
|
|
|
|
// URL, and returns clients to any that are found. An error is returned if
|
|
|
|
// there was an error probing the service.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered service URL.
|
|
|
|
func NewLANHostConfigManagement1ClientsByURL(loc *url.URL) ([]*LANHostConfigManagement1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsByURL(loc, URN_LANHostConfigManagement_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newLANHostConfigManagement1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewLANHostConfigManagement1ClientsFromRootDevice discovers instances of the service in
|
|
|
|
// a given root device, and returns clients to any that are found. An error is
|
|
|
|
// returned if there was not at least one instance of the service within the
|
|
|
|
// device. The location parameter is simply assigned to the Location attribute
|
|
|
|
// of the wrapped ServiceClient(s).
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered root device.
|
|
|
|
func NewLANHostConfigManagement1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*LANHostConfigManagement1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_LANHostConfigManagement_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newLANHostConfigManagement1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func newLANHostConfigManagement1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*LANHostConfigManagement1 {
|
|
|
|
clients := make([]*LANHostConfigManagement1, len(genericClients))
|
|
|
|
for i := range genericClients {
|
|
|
|
clients[i] = &LANHostConfigManagement1{genericClients[i]}
|
|
|
|
}
|
|
|
|
return clients
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *LANHostConfigManagement1) SetDHCPServerConfigurableCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewDHCPServerConfigurable bool,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewDHCPServerConfigurable string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewDHCPServerConfigurable, err = soap.MarshalBoolean(NewDHCPServerConfigurable); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "SetDHCPServerConfigurable", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetDHCPServerConfigurable is the legacy version of SetDHCPServerConfigurableCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) SetDHCPServerConfigurable(NewDHCPServerConfigurable bool) (err error) {
|
|
|
|
return client.SetDHCPServerConfigurableCtx(context.Background(),
|
|
|
|
NewDHCPServerConfigurable,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) GetDHCPServerConfigurableCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewDHCPServerConfigurable bool, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewDHCPServerConfigurable string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "GetDHCPServerConfigurable", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewDHCPServerConfigurable, err = soap.UnmarshalBoolean(response.NewDHCPServerConfigurable); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDHCPServerConfigurable is the legacy version of GetDHCPServerConfigurableCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) GetDHCPServerConfigurable() (NewDHCPServerConfigurable bool, err error) {
|
|
|
|
return client.GetDHCPServerConfigurableCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) SetDHCPRelayCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewDHCPRelay bool,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewDHCPRelay string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewDHCPRelay, err = soap.MarshalBoolean(NewDHCPRelay); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "SetDHCPRelay", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetDHCPRelay is the legacy version of SetDHCPRelayCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) SetDHCPRelay(NewDHCPRelay bool) (err error) {
|
|
|
|
return client.SetDHCPRelayCtx(context.Background(),
|
|
|
|
NewDHCPRelay,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) GetDHCPRelayCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewDHCPRelay bool, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewDHCPRelay string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "GetDHCPRelay", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewDHCPRelay, err = soap.UnmarshalBoolean(response.NewDHCPRelay); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDHCPRelay is the legacy version of GetDHCPRelayCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) GetDHCPRelay() (NewDHCPRelay bool, err error) {
|
|
|
|
return client.GetDHCPRelayCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) SetSubnetMaskCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewSubnetMask string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewSubnetMask string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewSubnetMask, err = soap.MarshalString(NewSubnetMask); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "SetSubnetMask", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetSubnetMask is the legacy version of SetSubnetMaskCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) SetSubnetMask(NewSubnetMask string) (err error) {
|
|
|
|
return client.SetSubnetMaskCtx(context.Background(),
|
|
|
|
NewSubnetMask,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) GetSubnetMaskCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewSubnetMask string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewSubnetMask string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "GetSubnetMask", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewSubnetMask, err = soap.UnmarshalString(response.NewSubnetMask); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetSubnetMask is the legacy version of GetSubnetMaskCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) GetSubnetMask() (NewSubnetMask string, err error) {
|
|
|
|
return client.GetSubnetMaskCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) SetIPRouterCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewIPRouters string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewIPRouters string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewIPRouters, err = soap.MarshalString(NewIPRouters); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "SetIPRouter", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetIPRouter is the legacy version of SetIPRouterCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) SetIPRouter(NewIPRouters string) (err error) {
|
|
|
|
return client.SetIPRouterCtx(context.Background(),
|
|
|
|
NewIPRouters,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) DeleteIPRouterCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewIPRouters string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewIPRouters string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewIPRouters, err = soap.MarshalString(NewIPRouters); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "DeleteIPRouter", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// DeleteIPRouter is the legacy version of DeleteIPRouterCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) DeleteIPRouter(NewIPRouters string) (err error) {
|
|
|
|
return client.DeleteIPRouterCtx(context.Background(),
|
|
|
|
NewIPRouters,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) GetIPRoutersListCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewIPRouters string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewIPRouters string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "GetIPRoutersList", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewIPRouters, err = soap.UnmarshalString(response.NewIPRouters); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetIPRoutersList is the legacy version of GetIPRoutersListCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) GetIPRoutersList() (NewIPRouters string, err error) {
|
|
|
|
return client.GetIPRoutersListCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) SetDomainNameCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewDomainName string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewDomainName string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewDomainName, err = soap.MarshalString(NewDomainName); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "SetDomainName", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetDomainName is the legacy version of SetDomainNameCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) SetDomainName(NewDomainName string) (err error) {
|
|
|
|
return client.SetDomainNameCtx(context.Background(),
|
|
|
|
NewDomainName,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) GetDomainNameCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewDomainName string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewDomainName string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "GetDomainName", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewDomainName, err = soap.UnmarshalString(response.NewDomainName); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDomainName is the legacy version of GetDomainNameCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) GetDomainName() (NewDomainName string, err error) {
|
|
|
|
return client.GetDomainNameCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) SetAddressRangeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewMinAddress string,
|
|
|
|
NewMaxAddress string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewMinAddress string
|
|
|
|
NewMaxAddress string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewMinAddress, err = soap.MarshalString(NewMinAddress); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewMaxAddress, err = soap.MarshalString(NewMaxAddress); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "SetAddressRange", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetAddressRange is the legacy version of SetAddressRangeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) SetAddressRange(NewMinAddress string, NewMaxAddress string) (err error) {
|
|
|
|
return client.SetAddressRangeCtx(context.Background(),
|
|
|
|
NewMinAddress,
|
|
|
|
NewMaxAddress,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) GetAddressRangeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewMinAddress string, NewMaxAddress string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewMinAddress string
|
|
|
|
NewMaxAddress string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "GetAddressRange", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewMinAddress, err = soap.UnmarshalString(response.NewMinAddress); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewMaxAddress, err = soap.UnmarshalString(response.NewMaxAddress); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetAddressRange is the legacy version of GetAddressRangeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) GetAddressRange() (NewMinAddress string, NewMaxAddress string, err error) {
|
|
|
|
return client.GetAddressRangeCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) SetReservedAddressCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewReservedAddresses string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewReservedAddresses string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewReservedAddresses, err = soap.MarshalString(NewReservedAddresses); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "SetReservedAddress", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetReservedAddress is the legacy version of SetReservedAddressCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) SetReservedAddress(NewReservedAddresses string) (err error) {
|
|
|
|
return client.SetReservedAddressCtx(context.Background(),
|
|
|
|
NewReservedAddresses,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) DeleteReservedAddressCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewReservedAddresses string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewReservedAddresses string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewReservedAddresses, err = soap.MarshalString(NewReservedAddresses); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "DeleteReservedAddress", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// DeleteReservedAddress is the legacy version of DeleteReservedAddressCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) DeleteReservedAddress(NewReservedAddresses string) (err error) {
|
|
|
|
return client.DeleteReservedAddressCtx(context.Background(),
|
|
|
|
NewReservedAddresses,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) GetReservedAddressesCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewReservedAddresses string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewReservedAddresses string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "GetReservedAddresses", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewReservedAddresses, err = soap.UnmarshalString(response.NewReservedAddresses); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetReservedAddresses is the legacy version of GetReservedAddressesCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) GetReservedAddresses() (NewReservedAddresses string, err error) {
|
|
|
|
return client.GetReservedAddressesCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) SetDNSServerCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewDNSServers string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewDNSServers string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewDNSServers, err = soap.MarshalString(NewDNSServers); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "SetDNSServer", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetDNSServer is the legacy version of SetDNSServerCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) SetDNSServer(NewDNSServers string) (err error) {
|
|
|
|
return client.SetDNSServerCtx(context.Background(),
|
|
|
|
NewDNSServers,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) DeleteDNSServerCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewDNSServers string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewDNSServers string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewDNSServers, err = soap.MarshalString(NewDNSServers); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "DeleteDNSServer", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// DeleteDNSServer is the legacy version of DeleteDNSServerCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) DeleteDNSServer(NewDNSServers string) (err error) {
|
|
|
|
return client.DeleteDNSServerCtx(context.Background(),
|
|
|
|
NewDNSServers,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *LANHostConfigManagement1) GetDNSServersCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewDNSServers string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewDNSServers string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_LANHostConfigManagement_1, "GetDNSServers", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewDNSServers, err = soap.UnmarshalString(response.NewDNSServers); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDNSServers is the legacy version of GetDNSServersCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *LANHostConfigManagement1) GetDNSServers() (NewDNSServers string, err error) {
|
|
|
|
return client.GetDNSServersCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
// Layer3Forwarding1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:Layer3Forwarding:1". See
|
|
|
|
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
|
|
|
|
// are provided for informational value.
|
|
|
|
type Layer3Forwarding1 struct {
|
|
|
|
goupnp.ServiceClient
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewLayer3Forwarding1Clients discovers instances of the service on the network,
|
|
|
|
// and returns clients to any that are found. errors will contain an error for
|
|
|
|
// any devices that replied but which could not be queried, and err will be set
|
|
|
|
// if the discovery process failed outright.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package.
|
|
|
|
func NewLayer3Forwarding1Clients() (clients []*Layer3Forwarding1, errors []error, err error) {
|
|
|
|
var genericClients []goupnp.ServiceClient
|
|
|
|
if genericClients, errors, err = goupnp.NewServiceClients(URN_Layer3Forwarding_1); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
clients = newLayer3Forwarding1ClientsFromGenericClients(genericClients)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewLayer3Forwarding1ClientsByURL discovers instances of the service at the given
|
|
|
|
// URL, and returns clients to any that are found. An error is returned if
|
|
|
|
// there was an error probing the service.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered service URL.
|
|
|
|
func NewLayer3Forwarding1ClientsByURL(loc *url.URL) ([]*Layer3Forwarding1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsByURL(loc, URN_Layer3Forwarding_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newLayer3Forwarding1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewLayer3Forwarding1ClientsFromRootDevice discovers instances of the service in
|
|
|
|
// a given root device, and returns clients to any that are found. An error is
|
|
|
|
// returned if there was not at least one instance of the service within the
|
|
|
|
// device. The location parameter is simply assigned to the Location attribute
|
|
|
|
// of the wrapped ServiceClient(s).
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered root device.
|
|
|
|
func NewLayer3Forwarding1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*Layer3Forwarding1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_Layer3Forwarding_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newLayer3Forwarding1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func newLayer3Forwarding1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*Layer3Forwarding1 {
|
|
|
|
clients := make([]*Layer3Forwarding1, len(genericClients))
|
|
|
|
for i := range genericClients {
|
|
|
|
clients[i] = &Layer3Forwarding1{genericClients[i]}
|
|
|
|
}
|
|
|
|
return clients
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *Layer3Forwarding1) SetDefaultConnectionServiceCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewDefaultConnectionService string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewDefaultConnectionService string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewDefaultConnectionService, err = soap.MarshalString(NewDefaultConnectionService); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_Layer3Forwarding_1, "SetDefaultConnectionService", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetDefaultConnectionService is the legacy version of SetDefaultConnectionServiceCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *Layer3Forwarding1) SetDefaultConnectionService(NewDefaultConnectionService string) (err error) {
|
|
|
|
return client.SetDefaultConnectionServiceCtx(context.Background(),
|
|
|
|
NewDefaultConnectionService,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *Layer3Forwarding1) GetDefaultConnectionServiceCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewDefaultConnectionService string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewDefaultConnectionService string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_Layer3Forwarding_1, "GetDefaultConnectionService", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewDefaultConnectionService, err = soap.UnmarshalString(response.NewDefaultConnectionService); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDefaultConnectionService is the legacy version of GetDefaultConnectionServiceCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *Layer3Forwarding1) GetDefaultConnectionService() (NewDefaultConnectionService string, err error) {
|
|
|
|
return client.GetDefaultConnectionServiceCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
// WANCableLinkConfig1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:WANCableLinkConfig:1". See
|
|
|
|
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
|
|
|
|
// are provided for informational value.
|
|
|
|
type WANCableLinkConfig1 struct {
|
|
|
|
goupnp.ServiceClient
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANCableLinkConfig1Clients discovers instances of the service on the network,
|
|
|
|
// and returns clients to any that are found. errors will contain an error for
|
|
|
|
// any devices that replied but which could not be queried, and err will be set
|
|
|
|
// if the discovery process failed outright.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package.
|
|
|
|
func NewWANCableLinkConfig1Clients() (clients []*WANCableLinkConfig1, errors []error, err error) {
|
|
|
|
var genericClients []goupnp.ServiceClient
|
|
|
|
if genericClients, errors, err = goupnp.NewServiceClients(URN_WANCableLinkConfig_1); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
clients = newWANCableLinkConfig1ClientsFromGenericClients(genericClients)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANCableLinkConfig1ClientsByURL discovers instances of the service at the given
|
|
|
|
// URL, and returns clients to any that are found. An error is returned if
|
|
|
|
// there was an error probing the service.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered service URL.
|
|
|
|
func NewWANCableLinkConfig1ClientsByURL(loc *url.URL) ([]*WANCableLinkConfig1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsByURL(loc, URN_WANCableLinkConfig_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANCableLinkConfig1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANCableLinkConfig1ClientsFromRootDevice discovers instances of the service in
|
|
|
|
// a given root device, and returns clients to any that are found. An error is
|
|
|
|
// returned if there was not at least one instance of the service within the
|
|
|
|
// device. The location parameter is simply assigned to the Location attribute
|
|
|
|
// of the wrapped ServiceClient(s).
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered root device.
|
|
|
|
func NewWANCableLinkConfig1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*WANCableLinkConfig1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_WANCableLinkConfig_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANCableLinkConfig1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func newWANCableLinkConfig1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*WANCableLinkConfig1 {
|
|
|
|
clients := make([]*WANCableLinkConfig1, len(genericClients))
|
|
|
|
for i := range genericClients {
|
|
|
|
clients[i] = &WANCableLinkConfig1{genericClients[i]}
|
|
|
|
}
|
|
|
|
return clients
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewCableLinkConfigState: allowed values: notReady, dsSyncComplete, usParamAcquired, rangingComplete, ipComplete, todEstablished, paramTransferComplete, registrationComplete, operational, accessDenied
|
|
|
|
//
|
|
|
|
// * NewLinkType: allowed values: Ethernet
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANCableLinkConfig1) GetCableLinkConfigInfoCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewCableLinkConfigState string, NewLinkType string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewCableLinkConfigState string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewLinkType string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCableLinkConfig_1, "GetCableLinkConfigInfo", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewCableLinkConfigState, err = soap.UnmarshalString(response.NewCableLinkConfigState); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewLinkType, err = soap.UnmarshalString(response.NewLinkType); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetCableLinkConfigInfo is the legacy version of GetCableLinkConfigInfoCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCableLinkConfig1) GetCableLinkConfigInfo() (NewCableLinkConfigState string, NewLinkType string, err error) {
|
|
|
|
return client.GetCableLinkConfigInfoCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCableLinkConfig1) GetDownstreamFrequencyCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewDownstreamFrequency uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewDownstreamFrequency string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCableLinkConfig_1, "GetDownstreamFrequency", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewDownstreamFrequency, err = soap.UnmarshalUi4(response.NewDownstreamFrequency); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDownstreamFrequency is the legacy version of GetDownstreamFrequencyCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCableLinkConfig1) GetDownstreamFrequency() (NewDownstreamFrequency uint32, err error) {
|
|
|
|
return client.GetDownstreamFrequencyCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewDownstreamModulation: allowed values: 64QAM, 256QAM
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANCableLinkConfig1) GetDownstreamModulationCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewDownstreamModulation string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewDownstreamModulation string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCableLinkConfig_1, "GetDownstreamModulation", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewDownstreamModulation, err = soap.UnmarshalString(response.NewDownstreamModulation); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDownstreamModulation is the legacy version of GetDownstreamModulationCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCableLinkConfig1) GetDownstreamModulation() (NewDownstreamModulation string, err error) {
|
|
|
|
return client.GetDownstreamModulationCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCableLinkConfig1) GetUpstreamFrequencyCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewUpstreamFrequency uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewUpstreamFrequency string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCableLinkConfig_1, "GetUpstreamFrequency", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewUpstreamFrequency, err = soap.UnmarshalUi4(response.NewUpstreamFrequency); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetUpstreamFrequency is the legacy version of GetUpstreamFrequencyCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCableLinkConfig1) GetUpstreamFrequency() (NewUpstreamFrequency uint32, err error) {
|
|
|
|
return client.GetUpstreamFrequencyCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewUpstreamModulation: allowed values: QPSK, 16QAM
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANCableLinkConfig1) GetUpstreamModulationCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewUpstreamModulation string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewUpstreamModulation string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCableLinkConfig_1, "GetUpstreamModulation", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewUpstreamModulation, err = soap.UnmarshalString(response.NewUpstreamModulation); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetUpstreamModulation is the legacy version of GetUpstreamModulationCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCableLinkConfig1) GetUpstreamModulation() (NewUpstreamModulation string, err error) {
|
|
|
|
return client.GetUpstreamModulationCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCableLinkConfig1) GetUpstreamChannelIDCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewUpstreamChannelID uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewUpstreamChannelID string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCableLinkConfig_1, "GetUpstreamChannelID", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewUpstreamChannelID, err = soap.UnmarshalUi4(response.NewUpstreamChannelID); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetUpstreamChannelID is the legacy version of GetUpstreamChannelIDCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCableLinkConfig1) GetUpstreamChannelID() (NewUpstreamChannelID uint32, err error) {
|
|
|
|
return client.GetUpstreamChannelIDCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCableLinkConfig1) GetUpstreamPowerLevelCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewUpstreamPowerLevel uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewUpstreamPowerLevel string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCableLinkConfig_1, "GetUpstreamPowerLevel", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewUpstreamPowerLevel, err = soap.UnmarshalUi4(response.NewUpstreamPowerLevel); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetUpstreamPowerLevel is the legacy version of GetUpstreamPowerLevelCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCableLinkConfig1) GetUpstreamPowerLevel() (NewUpstreamPowerLevel uint32, err error) {
|
|
|
|
return client.GetUpstreamPowerLevelCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCableLinkConfig1) GetBPIEncryptionEnabledCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewBPIEncryptionEnabled bool, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewBPIEncryptionEnabled string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCableLinkConfig_1, "GetBPIEncryptionEnabled", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewBPIEncryptionEnabled, err = soap.UnmarshalBoolean(response.NewBPIEncryptionEnabled); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetBPIEncryptionEnabled is the legacy version of GetBPIEncryptionEnabledCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCableLinkConfig1) GetBPIEncryptionEnabled() (NewBPIEncryptionEnabled bool, err error) {
|
|
|
|
return client.GetBPIEncryptionEnabledCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCableLinkConfig1) GetConfigFileCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewConfigFile string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewConfigFile string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCableLinkConfig_1, "GetConfigFile", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewConfigFile, err = soap.UnmarshalString(response.NewConfigFile); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetConfigFile is the legacy version of GetConfigFileCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCableLinkConfig1) GetConfigFile() (NewConfigFile string, err error) {
|
|
|
|
return client.GetConfigFileCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCableLinkConfig1) GetTFTPServerCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewTFTPServer string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewTFTPServer string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCableLinkConfig_1, "GetTFTPServer", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewTFTPServer, err = soap.UnmarshalString(response.NewTFTPServer); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetTFTPServer is the legacy version of GetTFTPServerCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCableLinkConfig1) GetTFTPServer() (NewTFTPServer string, err error) {
|
|
|
|
return client.GetTFTPServerCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
// WANCommonInterfaceConfig1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1". See
|
|
|
|
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
|
|
|
|
// are provided for informational value.
|
|
|
|
type WANCommonInterfaceConfig1 struct {
|
|
|
|
goupnp.ServiceClient
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANCommonInterfaceConfig1Clients discovers instances of the service on the network,
|
|
|
|
// and returns clients to any that are found. errors will contain an error for
|
|
|
|
// any devices that replied but which could not be queried, and err will be set
|
|
|
|
// if the discovery process failed outright.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package.
|
|
|
|
func NewWANCommonInterfaceConfig1Clients() (clients []*WANCommonInterfaceConfig1, errors []error, err error) {
|
|
|
|
var genericClients []goupnp.ServiceClient
|
|
|
|
if genericClients, errors, err = goupnp.NewServiceClients(URN_WANCommonInterfaceConfig_1); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
clients = newWANCommonInterfaceConfig1ClientsFromGenericClients(genericClients)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANCommonInterfaceConfig1ClientsByURL discovers instances of the service at the given
|
|
|
|
// URL, and returns clients to any that are found. An error is returned if
|
|
|
|
// there was an error probing the service.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered service URL.
|
|
|
|
func NewWANCommonInterfaceConfig1ClientsByURL(loc *url.URL) ([]*WANCommonInterfaceConfig1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsByURL(loc, URN_WANCommonInterfaceConfig_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANCommonInterfaceConfig1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANCommonInterfaceConfig1ClientsFromRootDevice discovers instances of the service in
|
|
|
|
// a given root device, and returns clients to any that are found. An error is
|
|
|
|
// returned if there was not at least one instance of the service within the
|
|
|
|
// device. The location parameter is simply assigned to the Location attribute
|
|
|
|
// of the wrapped ServiceClient(s).
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered root device.
|
|
|
|
func NewWANCommonInterfaceConfig1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*WANCommonInterfaceConfig1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_WANCommonInterfaceConfig_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANCommonInterfaceConfig1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func newWANCommonInterfaceConfig1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*WANCommonInterfaceConfig1 {
|
|
|
|
clients := make([]*WANCommonInterfaceConfig1, len(genericClients))
|
|
|
|
for i := range genericClients {
|
|
|
|
clients[i] = &WANCommonInterfaceConfig1{genericClients[i]}
|
|
|
|
}
|
|
|
|
return clients
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANCommonInterfaceConfig1) SetEnabledForInternetCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewEnabledForInternet bool,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewEnabledForInternet string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewEnabledForInternet, err = soap.MarshalBoolean(NewEnabledForInternet); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCommonInterfaceConfig_1, "SetEnabledForInternet", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetEnabledForInternet is the legacy version of SetEnabledForInternetCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCommonInterfaceConfig1) SetEnabledForInternet(NewEnabledForInternet bool) (err error) {
|
|
|
|
return client.SetEnabledForInternetCtx(context.Background(),
|
|
|
|
NewEnabledForInternet,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetEnabledForInternetCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewEnabledForInternet bool, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewEnabledForInternet string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCommonInterfaceConfig_1, "GetEnabledForInternet", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewEnabledForInternet, err = soap.UnmarshalBoolean(response.NewEnabledForInternet); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetEnabledForInternet is the legacy version of GetEnabledForInternetCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetEnabledForInternet() (NewEnabledForInternet bool, err error) {
|
|
|
|
return client.GetEnabledForInternetCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewWANAccessType: allowed values: DSL, POTS, Cable, Ethernet
|
|
|
|
//
|
|
|
|
// * NewPhysicalLinkStatus: allowed values: Up, Down
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANCommonInterfaceConfig1) GetCommonLinkPropertiesCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewWANAccessType string, NewLayer1UpstreamMaxBitRate uint32, NewLayer1DownstreamMaxBitRate uint32, NewPhysicalLinkStatus string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewWANAccessType string
|
|
|
|
NewLayer1UpstreamMaxBitRate string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewLayer1DownstreamMaxBitRate string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewPhysicalLinkStatus string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCommonInterfaceConfig_1, "GetCommonLinkProperties", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewWANAccessType, err = soap.UnmarshalString(response.NewWANAccessType); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewLayer1UpstreamMaxBitRate, err = soap.UnmarshalUi4(response.NewLayer1UpstreamMaxBitRate); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewLayer1DownstreamMaxBitRate, err = soap.UnmarshalUi4(response.NewLayer1DownstreamMaxBitRate); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewPhysicalLinkStatus, err = soap.UnmarshalString(response.NewPhysicalLinkStatus); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetCommonLinkProperties is the legacy version of GetCommonLinkPropertiesCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetCommonLinkProperties() (NewWANAccessType string, NewLayer1UpstreamMaxBitRate uint32, NewLayer1DownstreamMaxBitRate uint32, NewPhysicalLinkStatus string, err error) {
|
|
|
|
return client.GetCommonLinkPropertiesCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetWANAccessProviderCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewWANAccessProvider string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewWANAccessProvider string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCommonInterfaceConfig_1, "GetWANAccessProvider", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewWANAccessProvider, err = soap.UnmarshalString(response.NewWANAccessProvider); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetWANAccessProvider is the legacy version of GetWANAccessProviderCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetWANAccessProvider() (NewWANAccessProvider string, err error) {
|
|
|
|
return client.GetWANAccessProviderCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewMaximumActiveConnections: allowed value range: minimum=1, step=1
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANCommonInterfaceConfig1) GetMaximumActiveConnectionsCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewMaximumActiveConnections uint16, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewMaximumActiveConnections string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCommonInterfaceConfig_1, "GetMaximumActiveConnections", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewMaximumActiveConnections, err = soap.UnmarshalUi2(response.NewMaximumActiveConnections); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetMaximumActiveConnections is the legacy version of GetMaximumActiveConnectionsCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetMaximumActiveConnections() (NewMaximumActiveConnections uint16, err error) {
|
|
|
|
return client.GetMaximumActiveConnectionsCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalBytesSentCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewTotalBytesSent uint64, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewTotalBytesSent string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCommonInterfaceConfig_1, "GetTotalBytesSent", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
2019-06-09 07:24:20 +00:00
|
|
|
if NewTotalBytesSent, err = soap.UnmarshalUi8(response.NewTotalBytesSent); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetTotalBytesSent is the legacy version of GetTotalBytesSentCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalBytesSent() (NewTotalBytesSent uint64, err error) {
|
|
|
|
return client.GetTotalBytesSentCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalBytesReceivedCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewTotalBytesReceived uint64, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewTotalBytesReceived string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCommonInterfaceConfig_1, "GetTotalBytesReceived", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
2019-06-09 07:24:20 +00:00
|
|
|
if NewTotalBytesReceived, err = soap.UnmarshalUi8(response.NewTotalBytesReceived); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetTotalBytesReceived is the legacy version of GetTotalBytesReceivedCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalBytesReceived() (NewTotalBytesReceived uint64, err error) {
|
|
|
|
return client.GetTotalBytesReceivedCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalPacketsSentCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewTotalPacketsSent uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewTotalPacketsSent string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCommonInterfaceConfig_1, "GetTotalPacketsSent", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewTotalPacketsSent, err = soap.UnmarshalUi4(response.NewTotalPacketsSent); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetTotalPacketsSent is the legacy version of GetTotalPacketsSentCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalPacketsSent() (NewTotalPacketsSent uint32, err error) {
|
|
|
|
return client.GetTotalPacketsSentCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalPacketsReceivedCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewTotalPacketsReceived uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewTotalPacketsReceived string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCommonInterfaceConfig_1, "GetTotalPacketsReceived", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewTotalPacketsReceived, err = soap.UnmarshalUi4(response.NewTotalPacketsReceived); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetTotalPacketsReceived is the legacy version of GetTotalPacketsReceivedCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalPacketsReceived() (NewTotalPacketsReceived uint32, err error) {
|
|
|
|
return client.GetTotalPacketsReceivedCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetActiveConnectionCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewActiveConnectionIndex uint16,
|
|
|
|
) (NewActiveConnDeviceContainer string, NewActiveConnectionServiceID string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewActiveConnectionIndex string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewActiveConnectionIndex, err = soap.MarshalUi2(NewActiveConnectionIndex); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewActiveConnDeviceContainer string
|
|
|
|
NewActiveConnectionServiceID string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANCommonInterfaceConfig_1, "GetActiveConnection", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewActiveConnDeviceContainer, err = soap.UnmarshalString(response.NewActiveConnDeviceContainer); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewActiveConnectionServiceID, err = soap.UnmarshalString(response.NewActiveConnectionServiceID); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetActiveConnection is the legacy version of GetActiveConnectionCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetActiveConnection(NewActiveConnectionIndex uint16) (NewActiveConnDeviceContainer string, NewActiveConnectionServiceID string, err error) {
|
|
|
|
return client.GetActiveConnectionCtx(context.Background(),
|
|
|
|
NewActiveConnectionIndex,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
// WANDSLLinkConfig1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:WANDSLLinkConfig:1". See
|
|
|
|
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
|
|
|
|
// are provided for informational value.
|
|
|
|
type WANDSLLinkConfig1 struct {
|
|
|
|
goupnp.ServiceClient
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANDSLLinkConfig1Clients discovers instances of the service on the network,
|
|
|
|
// and returns clients to any that are found. errors will contain an error for
|
|
|
|
// any devices that replied but which could not be queried, and err will be set
|
|
|
|
// if the discovery process failed outright.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package.
|
|
|
|
func NewWANDSLLinkConfig1Clients() (clients []*WANDSLLinkConfig1, errors []error, err error) {
|
|
|
|
var genericClients []goupnp.ServiceClient
|
|
|
|
if genericClients, errors, err = goupnp.NewServiceClients(URN_WANDSLLinkConfig_1); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
clients = newWANDSLLinkConfig1ClientsFromGenericClients(genericClients)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANDSLLinkConfig1ClientsByURL discovers instances of the service at the given
|
|
|
|
// URL, and returns clients to any that are found. An error is returned if
|
|
|
|
// there was an error probing the service.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered service URL.
|
|
|
|
func NewWANDSLLinkConfig1ClientsByURL(loc *url.URL) ([]*WANDSLLinkConfig1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsByURL(loc, URN_WANDSLLinkConfig_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANDSLLinkConfig1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANDSLLinkConfig1ClientsFromRootDevice discovers instances of the service in
|
|
|
|
// a given root device, and returns clients to any that are found. An error is
|
|
|
|
// returned if there was not at least one instance of the service within the
|
|
|
|
// device. The location parameter is simply assigned to the Location attribute
|
|
|
|
// of the wrapped ServiceClient(s).
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered root device.
|
|
|
|
func NewWANDSLLinkConfig1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*WANDSLLinkConfig1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_WANDSLLinkConfig_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANDSLLinkConfig1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func newWANDSLLinkConfig1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*WANDSLLinkConfig1 {
|
|
|
|
clients := make([]*WANDSLLinkConfig1, len(genericClients))
|
|
|
|
for i := range genericClients {
|
|
|
|
clients[i] = &WANDSLLinkConfig1{genericClients[i]}
|
|
|
|
}
|
|
|
|
return clients
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANDSLLinkConfig1) SetDSLLinkTypeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewLinkType string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewLinkType string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewLinkType, err = soap.MarshalString(NewLinkType); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANDSLLinkConfig_1, "SetDSLLinkType", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetDSLLinkType is the legacy version of SetDSLLinkTypeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANDSLLinkConfig1) SetDSLLinkType(NewLinkType string) (err error) {
|
|
|
|
return client.SetDSLLinkTypeCtx(context.Background(),
|
|
|
|
NewLinkType,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewLinkStatus: allowed values: Up, Down
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANDSLLinkConfig1) GetDSLLinkInfoCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewLinkType string, NewLinkStatus string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewLinkType string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewLinkStatus string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANDSLLinkConfig_1, "GetDSLLinkInfo", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewLinkType, err = soap.UnmarshalString(response.NewLinkType); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewLinkStatus, err = soap.UnmarshalString(response.NewLinkStatus); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDSLLinkInfo is the legacy version of GetDSLLinkInfoCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANDSLLinkConfig1) GetDSLLinkInfo() (NewLinkType string, NewLinkStatus string, err error) {
|
|
|
|
return client.GetDSLLinkInfoCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANDSLLinkConfig1) GetAutoConfigCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewAutoConfig bool, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewAutoConfig string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANDSLLinkConfig_1, "GetAutoConfig", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewAutoConfig, err = soap.UnmarshalBoolean(response.NewAutoConfig); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetAutoConfig is the legacy version of GetAutoConfigCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANDSLLinkConfig1) GetAutoConfig() (NewAutoConfig bool, err error) {
|
|
|
|
return client.GetAutoConfigCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANDSLLinkConfig1) GetModulationTypeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewModulationType string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewModulationType string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANDSLLinkConfig_1, "GetModulationType", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewModulationType, err = soap.UnmarshalString(response.NewModulationType); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetModulationType is the legacy version of GetModulationTypeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANDSLLinkConfig1) GetModulationType() (NewModulationType string, err error) {
|
|
|
|
return client.GetModulationTypeCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANDSLLinkConfig1) SetDestinationAddressCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewDestinationAddress string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewDestinationAddress string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewDestinationAddress, err = soap.MarshalString(NewDestinationAddress); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANDSLLinkConfig_1, "SetDestinationAddress", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetDestinationAddress is the legacy version of SetDestinationAddressCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANDSLLinkConfig1) SetDestinationAddress(NewDestinationAddress string) (err error) {
|
|
|
|
return client.SetDestinationAddressCtx(context.Background(),
|
|
|
|
NewDestinationAddress,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANDSLLinkConfig1) GetDestinationAddressCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewDestinationAddress string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewDestinationAddress string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANDSLLinkConfig_1, "GetDestinationAddress", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewDestinationAddress, err = soap.UnmarshalString(response.NewDestinationAddress); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDestinationAddress is the legacy version of GetDestinationAddressCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANDSLLinkConfig1) GetDestinationAddress() (NewDestinationAddress string, err error) {
|
|
|
|
return client.GetDestinationAddressCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANDSLLinkConfig1) SetATMEncapsulationCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewATMEncapsulation string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewATMEncapsulation string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewATMEncapsulation, err = soap.MarshalString(NewATMEncapsulation); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANDSLLinkConfig_1, "SetATMEncapsulation", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetATMEncapsulation is the legacy version of SetATMEncapsulationCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANDSLLinkConfig1) SetATMEncapsulation(NewATMEncapsulation string) (err error) {
|
|
|
|
return client.SetATMEncapsulationCtx(context.Background(),
|
|
|
|
NewATMEncapsulation,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANDSLLinkConfig1) GetATMEncapsulationCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewATMEncapsulation string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewATMEncapsulation string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANDSLLinkConfig_1, "GetATMEncapsulation", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewATMEncapsulation, err = soap.UnmarshalString(response.NewATMEncapsulation); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetATMEncapsulation is the legacy version of GetATMEncapsulationCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANDSLLinkConfig1) GetATMEncapsulation() (NewATMEncapsulation string, err error) {
|
|
|
|
return client.GetATMEncapsulationCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANDSLLinkConfig1) SetFCSPreservedCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewFCSPreserved bool,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewFCSPreserved string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewFCSPreserved, err = soap.MarshalBoolean(NewFCSPreserved); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANDSLLinkConfig_1, "SetFCSPreserved", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetFCSPreserved is the legacy version of SetFCSPreservedCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANDSLLinkConfig1) SetFCSPreserved(NewFCSPreserved bool) (err error) {
|
|
|
|
return client.SetFCSPreservedCtx(context.Background(),
|
|
|
|
NewFCSPreserved,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANDSLLinkConfig1) GetFCSPreservedCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewFCSPreserved bool, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewFCSPreserved string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANDSLLinkConfig_1, "GetFCSPreserved", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewFCSPreserved, err = soap.UnmarshalBoolean(response.NewFCSPreserved); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetFCSPreserved is the legacy version of GetFCSPreservedCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANDSLLinkConfig1) GetFCSPreserved() (NewFCSPreserved bool, err error) {
|
|
|
|
return client.GetFCSPreservedCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
// WANEthernetLinkConfig1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:WANEthernetLinkConfig:1". See
|
|
|
|
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
|
|
|
|
// are provided for informational value.
|
|
|
|
type WANEthernetLinkConfig1 struct {
|
|
|
|
goupnp.ServiceClient
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANEthernetLinkConfig1Clients discovers instances of the service on the network,
|
|
|
|
// and returns clients to any that are found. errors will contain an error for
|
|
|
|
// any devices that replied but which could not be queried, and err will be set
|
|
|
|
// if the discovery process failed outright.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package.
|
|
|
|
func NewWANEthernetLinkConfig1Clients() (clients []*WANEthernetLinkConfig1, errors []error, err error) {
|
|
|
|
var genericClients []goupnp.ServiceClient
|
|
|
|
if genericClients, errors, err = goupnp.NewServiceClients(URN_WANEthernetLinkConfig_1); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
clients = newWANEthernetLinkConfig1ClientsFromGenericClients(genericClients)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANEthernetLinkConfig1ClientsByURL discovers instances of the service at the given
|
|
|
|
// URL, and returns clients to any that are found. An error is returned if
|
|
|
|
// there was an error probing the service.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered service URL.
|
|
|
|
func NewWANEthernetLinkConfig1ClientsByURL(loc *url.URL) ([]*WANEthernetLinkConfig1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsByURL(loc, URN_WANEthernetLinkConfig_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANEthernetLinkConfig1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANEthernetLinkConfig1ClientsFromRootDevice discovers instances of the service in
|
|
|
|
// a given root device, and returns clients to any that are found. An error is
|
|
|
|
// returned if there was not at least one instance of the service within the
|
|
|
|
// device. The location parameter is simply assigned to the Location attribute
|
|
|
|
// of the wrapped ServiceClient(s).
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered root device.
|
|
|
|
func NewWANEthernetLinkConfig1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*WANEthernetLinkConfig1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_WANEthernetLinkConfig_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANEthernetLinkConfig1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func newWANEthernetLinkConfig1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*WANEthernetLinkConfig1 {
|
|
|
|
clients := make([]*WANEthernetLinkConfig1, len(genericClients))
|
|
|
|
for i := range genericClients {
|
|
|
|
clients[i] = &WANEthernetLinkConfig1{genericClients[i]}
|
|
|
|
}
|
|
|
|
return clients
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewEthernetLinkStatus: allowed values: Up, Down
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANEthernetLinkConfig1) GetEthernetLinkStatusCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewEthernetLinkStatus string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewEthernetLinkStatus string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANEthernetLinkConfig_1, "GetEthernetLinkStatus", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewEthernetLinkStatus, err = soap.UnmarshalString(response.NewEthernetLinkStatus); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetEthernetLinkStatus is the legacy version of GetEthernetLinkStatusCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANEthernetLinkConfig1) GetEthernetLinkStatus() (NewEthernetLinkStatus string, err error) {
|
|
|
|
return client.GetEthernetLinkStatusCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
// WANIPConnection1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:WANIPConnection:1". See
|
|
|
|
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
|
|
|
|
// are provided for informational value.
|
|
|
|
type WANIPConnection1 struct {
|
|
|
|
goupnp.ServiceClient
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANIPConnection1Clients discovers instances of the service on the network,
|
|
|
|
// and returns clients to any that are found. errors will contain an error for
|
|
|
|
// any devices that replied but which could not be queried, and err will be set
|
|
|
|
// if the discovery process failed outright.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package.
|
|
|
|
func NewWANIPConnection1Clients() (clients []*WANIPConnection1, errors []error, err error) {
|
|
|
|
var genericClients []goupnp.ServiceClient
|
|
|
|
if genericClients, errors, err = goupnp.NewServiceClients(URN_WANIPConnection_1); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
clients = newWANIPConnection1ClientsFromGenericClients(genericClients)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANIPConnection1ClientsByURL discovers instances of the service at the given
|
|
|
|
// URL, and returns clients to any that are found. An error is returned if
|
|
|
|
// there was an error probing the service.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered service URL.
|
|
|
|
func NewWANIPConnection1ClientsByURL(loc *url.URL) ([]*WANIPConnection1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsByURL(loc, URN_WANIPConnection_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANIPConnection1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANIPConnection1ClientsFromRootDevice discovers instances of the service in
|
|
|
|
// a given root device, and returns clients to any that are found. An error is
|
|
|
|
// returned if there was not at least one instance of the service within the
|
|
|
|
// device. The location parameter is simply assigned to the Location attribute
|
|
|
|
// of the wrapped ServiceClient(s).
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered root device.
|
|
|
|
func NewWANIPConnection1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*WANIPConnection1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_WANIPConnection_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANIPConnection1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func newWANIPConnection1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*WANIPConnection1 {
|
|
|
|
clients := make([]*WANIPConnection1, len(genericClients))
|
|
|
|
for i := range genericClients {
|
|
|
|
clients[i] = &WANIPConnection1{genericClients[i]}
|
|
|
|
}
|
|
|
|
return clients
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANIPConnection1) SetConnectionTypeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewConnectionType string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewConnectionType string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewConnectionType, err = soap.MarshalString(NewConnectionType); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "SetConnectionType", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetConnectionType is the legacy version of SetConnectionTypeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) SetConnectionType(NewConnectionType string) (err error) {
|
|
|
|
return client.SetConnectionTypeCtx(context.Background(),
|
|
|
|
NewConnectionType,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewPossibleConnectionTypes: allowed values: Unconfigured, IP_Routed, IP_Bridged
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANIPConnection1) GetConnectionTypeInfoCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewConnectionType string, NewPossibleConnectionTypes string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewConnectionType string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewPossibleConnectionTypes string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "GetConnectionTypeInfo", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewConnectionType, err = soap.UnmarshalString(response.NewConnectionType); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewPossibleConnectionTypes, err = soap.UnmarshalString(response.NewPossibleConnectionTypes); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetConnectionTypeInfo is the legacy version of GetConnectionTypeInfoCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) GetConnectionTypeInfo() (NewConnectionType string, NewPossibleConnectionTypes string, err error) {
|
|
|
|
return client.GetConnectionTypeInfoCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANIPConnection1) RequestConnectionCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "RequestConnection", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// RequestConnection is the legacy version of RequestConnectionCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) RequestConnection() (err error) {
|
|
|
|
return client.RequestConnectionCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANIPConnection1) RequestTerminationCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "RequestTermination", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// RequestTermination is the legacy version of RequestTerminationCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) RequestTermination() (err error) {
|
|
|
|
return client.RequestTerminationCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANIPConnection1) ForceTerminationCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "ForceTermination", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// ForceTermination is the legacy version of ForceTerminationCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) ForceTermination() (err error) {
|
|
|
|
return client.ForceTerminationCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANIPConnection1) SetAutoDisconnectTimeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewAutoDisconnectTime uint32,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewAutoDisconnectTime string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewAutoDisconnectTime, err = soap.MarshalUi4(NewAutoDisconnectTime); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "SetAutoDisconnectTime", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetAutoDisconnectTime is the legacy version of SetAutoDisconnectTimeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) SetAutoDisconnectTime(NewAutoDisconnectTime uint32) (err error) {
|
|
|
|
return client.SetAutoDisconnectTimeCtx(context.Background(),
|
|
|
|
NewAutoDisconnectTime,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANIPConnection1) SetIdleDisconnectTimeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewIdleDisconnectTime uint32,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewIdleDisconnectTime string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewIdleDisconnectTime, err = soap.MarshalUi4(NewIdleDisconnectTime); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "SetIdleDisconnectTime", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetIdleDisconnectTime is the legacy version of SetIdleDisconnectTimeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) SetIdleDisconnectTime(NewIdleDisconnectTime uint32) (err error) {
|
|
|
|
return client.SetIdleDisconnectTimeCtx(context.Background(),
|
|
|
|
NewIdleDisconnectTime,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANIPConnection1) SetWarnDisconnectDelayCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewWarnDisconnectDelay uint32,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewWarnDisconnectDelay string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewWarnDisconnectDelay, err = soap.MarshalUi4(NewWarnDisconnectDelay); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "SetWarnDisconnectDelay", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetWarnDisconnectDelay is the legacy version of SetWarnDisconnectDelayCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) SetWarnDisconnectDelay(NewWarnDisconnectDelay uint32) (err error) {
|
|
|
|
return client.SetWarnDisconnectDelayCtx(context.Background(),
|
|
|
|
NewWarnDisconnectDelay,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewConnectionStatus: allowed values: Unconfigured, Connected, Disconnected
|
|
|
|
//
|
|
|
|
// * NewLastConnectionError: allowed values: ERROR_NONE
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANIPConnection1) GetStatusInfoCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewConnectionStatus string, NewLastConnectionError string, NewUptime uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewConnectionStatus string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewLastConnectionError string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewUptime string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "GetStatusInfo", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewConnectionStatus, err = soap.UnmarshalString(response.NewConnectionStatus); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewLastConnectionError, err = soap.UnmarshalString(response.NewLastConnectionError); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewUptime, err = soap.UnmarshalUi4(response.NewUptime); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetStatusInfo is the legacy version of GetStatusInfoCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) GetStatusInfo() (NewConnectionStatus string, NewLastConnectionError string, NewUptime uint32, err error) {
|
|
|
|
return client.GetStatusInfoCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANIPConnection1) GetAutoDisconnectTimeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewAutoDisconnectTime uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewAutoDisconnectTime string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "GetAutoDisconnectTime", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewAutoDisconnectTime, err = soap.UnmarshalUi4(response.NewAutoDisconnectTime); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetAutoDisconnectTime is the legacy version of GetAutoDisconnectTimeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) GetAutoDisconnectTime() (NewAutoDisconnectTime uint32, err error) {
|
|
|
|
return client.GetAutoDisconnectTimeCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANIPConnection1) GetIdleDisconnectTimeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewIdleDisconnectTime uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewIdleDisconnectTime string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "GetIdleDisconnectTime", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewIdleDisconnectTime, err = soap.UnmarshalUi4(response.NewIdleDisconnectTime); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetIdleDisconnectTime is the legacy version of GetIdleDisconnectTimeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) GetIdleDisconnectTime() (NewIdleDisconnectTime uint32, err error) {
|
|
|
|
return client.GetIdleDisconnectTimeCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANIPConnection1) GetWarnDisconnectDelayCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewWarnDisconnectDelay uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewWarnDisconnectDelay string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "GetWarnDisconnectDelay", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewWarnDisconnectDelay, err = soap.UnmarshalUi4(response.NewWarnDisconnectDelay); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetWarnDisconnectDelay is the legacy version of GetWarnDisconnectDelayCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) GetWarnDisconnectDelay() (NewWarnDisconnectDelay uint32, err error) {
|
|
|
|
return client.GetWarnDisconnectDelayCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANIPConnection1) GetNATRSIPStatusCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewRSIPAvailable bool, NewNATEnabled bool, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewRSIPAvailable string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewNATEnabled string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "GetNATRSIPStatus", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewRSIPAvailable, err = soap.UnmarshalBoolean(response.NewRSIPAvailable); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewNATEnabled, err = soap.UnmarshalBoolean(response.NewNATEnabled); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetNATRSIPStatus is the legacy version of GetNATRSIPStatusCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) GetNATRSIPStatus() (NewRSIPAvailable bool, NewNATEnabled bool, err error) {
|
|
|
|
return client.GetNATRSIPStatusCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewProtocol: allowed values: TCP, UDP
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANIPConnection1) GetGenericPortMappingEntryCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewPortMappingIndex uint16,
|
|
|
|
) (NewRemoteHost string, NewExternalPort uint16, NewProtocol string, NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewPortMappingIndex string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewPortMappingIndex, err = soap.MarshalUi2(NewPortMappingIndex); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewPortMappingDescription string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewLeaseDuration string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "GetGenericPortMappingEntry", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewRemoteHost, err = soap.UnmarshalString(response.NewRemoteHost); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewExternalPort, err = soap.UnmarshalUi2(response.NewExternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewProtocol, err = soap.UnmarshalString(response.NewProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewInternalPort, err = soap.UnmarshalUi2(response.NewInternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewInternalClient, err = soap.UnmarshalString(response.NewInternalClient); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewEnabled, err = soap.UnmarshalBoolean(response.NewEnabled); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewPortMappingDescription, err = soap.UnmarshalString(response.NewPortMappingDescription); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewLeaseDuration, err = soap.UnmarshalUi4(response.NewLeaseDuration); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetGenericPortMappingEntry is the legacy version of GetGenericPortMappingEntryCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) GetGenericPortMappingEntry(NewPortMappingIndex uint16) (NewRemoteHost string, NewExternalPort uint16, NewProtocol string, NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
|
|
|
return client.GetGenericPortMappingEntryCtx(context.Background(),
|
|
|
|
NewPortMappingIndex,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Arguments:
|
|
|
|
//
|
|
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANIPConnection1) GetSpecificPortMappingEntryCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewRemoteHost string,
|
|
|
|
NewExternalPort uint16,
|
|
|
|
NewProtocol string,
|
|
|
|
) (NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewRemoteHost string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewExternalPort string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewProtocol string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewRemoteHost, err = soap.MarshalString(NewRemoteHost); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewExternalPort, err = soap.MarshalUi2(NewExternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewProtocol, err = soap.MarshalString(NewProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewPortMappingDescription string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewLeaseDuration string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "GetSpecificPortMappingEntry", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewInternalPort, err = soap.UnmarshalUi2(response.NewInternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewInternalClient, err = soap.UnmarshalString(response.NewInternalClient); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewEnabled, err = soap.UnmarshalBoolean(response.NewEnabled); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewPortMappingDescription, err = soap.UnmarshalString(response.NewPortMappingDescription); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewLeaseDuration, err = soap.UnmarshalUi4(response.NewLeaseDuration); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetSpecificPortMappingEntry is the legacy version of GetSpecificPortMappingEntryCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) GetSpecificPortMappingEntry(NewRemoteHost string, NewExternalPort uint16, NewProtocol string) (NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
|
|
|
return client.GetSpecificPortMappingEntryCtx(context.Background(),
|
|
|
|
NewRemoteHost,
|
|
|
|
NewExternalPort,
|
|
|
|
NewProtocol,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Arguments:
|
|
|
|
//
|
|
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANIPConnection1) AddPortMappingCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewRemoteHost string,
|
|
|
|
NewExternalPort uint16,
|
|
|
|
NewProtocol string,
|
|
|
|
NewInternalPort uint16,
|
|
|
|
NewInternalClient string,
|
|
|
|
NewEnabled bool,
|
|
|
|
NewPortMappingDescription string,
|
|
|
|
NewLeaseDuration uint32,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewPortMappingDescription string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewLeaseDuration string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewRemoteHost, err = soap.MarshalString(NewRemoteHost); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewExternalPort, err = soap.MarshalUi2(NewExternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewProtocol, err = soap.MarshalString(NewProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewInternalPort, err = soap.MarshalUi2(NewInternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewInternalClient, err = soap.MarshalString(NewInternalClient); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewEnabled, err = soap.MarshalBoolean(NewEnabled); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewPortMappingDescription, err = soap.MarshalString(NewPortMappingDescription); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewLeaseDuration, err = soap.MarshalUi4(NewLeaseDuration); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "AddPortMapping", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// AddPortMapping is the legacy version of AddPortMappingCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) AddPortMapping(NewRemoteHost string, NewExternalPort uint16, NewProtocol string, NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32) (err error) {
|
|
|
|
return client.AddPortMappingCtx(context.Background(),
|
|
|
|
NewRemoteHost,
|
|
|
|
NewExternalPort,
|
|
|
|
NewProtocol,
|
|
|
|
NewInternalPort,
|
|
|
|
NewInternalClient,
|
|
|
|
NewEnabled,
|
|
|
|
NewPortMappingDescription,
|
|
|
|
NewLeaseDuration,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Arguments:
|
|
|
|
//
|
|
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANIPConnection1) DeletePortMappingCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewRemoteHost string,
|
|
|
|
NewExternalPort uint16,
|
|
|
|
NewProtocol string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewRemoteHost string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewExternalPort string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewProtocol string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewRemoteHost, err = soap.MarshalString(NewRemoteHost); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewExternalPort, err = soap.MarshalUi2(NewExternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewProtocol, err = soap.MarshalString(NewProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "DeletePortMapping", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// DeletePortMapping is the legacy version of DeletePortMappingCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) DeletePortMapping(NewRemoteHost string, NewExternalPort uint16, NewProtocol string) (err error) {
|
|
|
|
return client.DeletePortMappingCtx(context.Background(),
|
|
|
|
NewRemoteHost,
|
|
|
|
NewExternalPort,
|
|
|
|
NewProtocol,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANIPConnection1) GetExternalIPAddressCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewExternalIPAddress string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewExternalIPAddress string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANIPConnection_1, "GetExternalIPAddress", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewExternalIPAddress, err = soap.UnmarshalString(response.NewExternalIPAddress); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetExternalIPAddress is the legacy version of GetExternalIPAddressCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANIPConnection1) GetExternalIPAddress() (NewExternalIPAddress string, err error) {
|
|
|
|
return client.GetExternalIPAddressCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
// WANPOTSLinkConfig1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:WANPOTSLinkConfig:1". See
|
|
|
|
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
|
|
|
|
// are provided for informational value.
|
|
|
|
type WANPOTSLinkConfig1 struct {
|
|
|
|
goupnp.ServiceClient
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANPOTSLinkConfig1Clients discovers instances of the service on the network,
|
|
|
|
// and returns clients to any that are found. errors will contain an error for
|
|
|
|
// any devices that replied but which could not be queried, and err will be set
|
|
|
|
// if the discovery process failed outright.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package.
|
|
|
|
func NewWANPOTSLinkConfig1Clients() (clients []*WANPOTSLinkConfig1, errors []error, err error) {
|
|
|
|
var genericClients []goupnp.ServiceClient
|
|
|
|
if genericClients, errors, err = goupnp.NewServiceClients(URN_WANPOTSLinkConfig_1); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
clients = newWANPOTSLinkConfig1ClientsFromGenericClients(genericClients)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANPOTSLinkConfig1ClientsByURL discovers instances of the service at the given
|
|
|
|
// URL, and returns clients to any that are found. An error is returned if
|
|
|
|
// there was an error probing the service.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered service URL.
|
|
|
|
func NewWANPOTSLinkConfig1ClientsByURL(loc *url.URL) ([]*WANPOTSLinkConfig1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsByURL(loc, URN_WANPOTSLinkConfig_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANPOTSLinkConfig1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANPOTSLinkConfig1ClientsFromRootDevice discovers instances of the service in
|
|
|
|
// a given root device, and returns clients to any that are found. An error is
|
|
|
|
// returned if there was not at least one instance of the service within the
|
|
|
|
// device. The location parameter is simply assigned to the Location attribute
|
|
|
|
// of the wrapped ServiceClient(s).
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered root device.
|
|
|
|
func NewWANPOTSLinkConfig1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*WANPOTSLinkConfig1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_WANPOTSLinkConfig_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANPOTSLinkConfig1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func newWANPOTSLinkConfig1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*WANPOTSLinkConfig1 {
|
|
|
|
clients := make([]*WANPOTSLinkConfig1, len(genericClients))
|
|
|
|
for i := range genericClients {
|
|
|
|
clients[i] = &WANPOTSLinkConfig1{genericClients[i]}
|
|
|
|
}
|
|
|
|
return clients
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Arguments:
|
|
|
|
//
|
|
|
|
// * NewLinkType: allowed values: PPP_Dialup
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANPOTSLinkConfig1) SetISPInfoCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewISPPhoneNumber string,
|
|
|
|
NewISPInfo string,
|
|
|
|
NewLinkType string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewISPPhoneNumber string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewISPInfo string
|
|
|
|
NewLinkType string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewISPPhoneNumber, err = soap.MarshalString(NewISPPhoneNumber); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewISPInfo, err = soap.MarshalString(NewISPInfo); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewLinkType, err = soap.MarshalString(NewLinkType); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPOTSLinkConfig_1, "SetISPInfo", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetISPInfo is the legacy version of SetISPInfoCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPOTSLinkConfig1) SetISPInfo(NewISPPhoneNumber string, NewISPInfo string, NewLinkType string) (err error) {
|
|
|
|
return client.SetISPInfoCtx(context.Background(),
|
|
|
|
NewISPPhoneNumber,
|
|
|
|
NewISPInfo,
|
|
|
|
NewLinkType,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPOTSLinkConfig1) SetCallRetryInfoCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewNumberOfRetries uint32,
|
|
|
|
NewDelayBetweenRetries uint32,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewNumberOfRetries string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewDelayBetweenRetries string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewNumberOfRetries, err = soap.MarshalUi4(NewNumberOfRetries); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewDelayBetweenRetries, err = soap.MarshalUi4(NewDelayBetweenRetries); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPOTSLinkConfig_1, "SetCallRetryInfo", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetCallRetryInfo is the legacy version of SetCallRetryInfoCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPOTSLinkConfig1) SetCallRetryInfo(NewNumberOfRetries uint32, NewDelayBetweenRetries uint32) (err error) {
|
|
|
|
return client.SetCallRetryInfoCtx(context.Background(),
|
|
|
|
NewNumberOfRetries,
|
|
|
|
NewDelayBetweenRetries,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewLinkType: allowed values: PPP_Dialup
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANPOTSLinkConfig1) GetISPInfoCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewISPPhoneNumber string, NewISPInfo string, NewLinkType string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewISPPhoneNumber string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewISPInfo string
|
|
|
|
NewLinkType string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPOTSLinkConfig_1, "GetISPInfo", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewISPPhoneNumber, err = soap.UnmarshalString(response.NewISPPhoneNumber); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewISPInfo, err = soap.UnmarshalString(response.NewISPInfo); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewLinkType, err = soap.UnmarshalString(response.NewLinkType); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetISPInfo is the legacy version of GetISPInfoCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPOTSLinkConfig1) GetISPInfo() (NewISPPhoneNumber string, NewISPInfo string, NewLinkType string, err error) {
|
|
|
|
return client.GetISPInfoCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPOTSLinkConfig1) GetCallRetryInfoCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewNumberOfRetries uint32, NewDelayBetweenRetries uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewNumberOfRetries string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewDelayBetweenRetries string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPOTSLinkConfig_1, "GetCallRetryInfo", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewNumberOfRetries, err = soap.UnmarshalUi4(response.NewNumberOfRetries); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewDelayBetweenRetries, err = soap.UnmarshalUi4(response.NewDelayBetweenRetries); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetCallRetryInfo is the legacy version of GetCallRetryInfoCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPOTSLinkConfig1) GetCallRetryInfo() (NewNumberOfRetries uint32, NewDelayBetweenRetries uint32, err error) {
|
|
|
|
return client.GetCallRetryInfoCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPOTSLinkConfig1) GetFclassCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewFclass string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewFclass string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPOTSLinkConfig_1, "GetFclass", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewFclass, err = soap.UnmarshalString(response.NewFclass); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetFclass is the legacy version of GetFclassCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPOTSLinkConfig1) GetFclass() (NewFclass string, err error) {
|
|
|
|
return client.GetFclassCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPOTSLinkConfig1) GetDataModulationSupportedCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewDataModulationSupported string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewDataModulationSupported string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPOTSLinkConfig_1, "GetDataModulationSupported", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewDataModulationSupported, err = soap.UnmarshalString(response.NewDataModulationSupported); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDataModulationSupported is the legacy version of GetDataModulationSupportedCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPOTSLinkConfig1) GetDataModulationSupported() (NewDataModulationSupported string, err error) {
|
|
|
|
return client.GetDataModulationSupportedCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPOTSLinkConfig1) GetDataProtocolCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewDataProtocol string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewDataProtocol string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPOTSLinkConfig_1, "GetDataProtocol", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewDataProtocol, err = soap.UnmarshalString(response.NewDataProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDataProtocol is the legacy version of GetDataProtocolCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPOTSLinkConfig1) GetDataProtocol() (NewDataProtocol string, err error) {
|
|
|
|
return client.GetDataProtocolCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPOTSLinkConfig1) GetDataCompressionCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewDataCompression string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewDataCompression string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPOTSLinkConfig_1, "GetDataCompression", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewDataCompression, err = soap.UnmarshalString(response.NewDataCompression); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetDataCompression is the legacy version of GetDataCompressionCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPOTSLinkConfig1) GetDataCompression() (NewDataCompression string, err error) {
|
|
|
|
return client.GetDataCompressionCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPOTSLinkConfig1) GetPlusVTRCommandSupportedCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewPlusVTRCommandSupported bool, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewPlusVTRCommandSupported string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPOTSLinkConfig_1, "GetPlusVTRCommandSupported", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewPlusVTRCommandSupported, err = soap.UnmarshalBoolean(response.NewPlusVTRCommandSupported); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetPlusVTRCommandSupported is the legacy version of GetPlusVTRCommandSupportedCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPOTSLinkConfig1) GetPlusVTRCommandSupported() (NewPlusVTRCommandSupported bool, err error) {
|
|
|
|
return client.GetPlusVTRCommandSupportedCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
// WANPPPConnection1 is a client for UPnP SOAP service with URN "urn:schemas-upnp-org:service:WANPPPConnection:1". See
|
|
|
|
// goupnp.ServiceClient, which contains RootDevice and Service attributes which
|
|
|
|
// are provided for informational value.
|
|
|
|
type WANPPPConnection1 struct {
|
|
|
|
goupnp.ServiceClient
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANPPPConnection1Clients discovers instances of the service on the network,
|
|
|
|
// and returns clients to any that are found. errors will contain an error for
|
|
|
|
// any devices that replied but which could not be queried, and err will be set
|
|
|
|
// if the discovery process failed outright.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package.
|
|
|
|
func NewWANPPPConnection1Clients() (clients []*WANPPPConnection1, errors []error, err error) {
|
|
|
|
var genericClients []goupnp.ServiceClient
|
|
|
|
if genericClients, errors, err = goupnp.NewServiceClients(URN_WANPPPConnection_1); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
clients = newWANPPPConnection1ClientsFromGenericClients(genericClients)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANPPPConnection1ClientsByURL discovers instances of the service at the given
|
|
|
|
// URL, and returns clients to any that are found. An error is returned if
|
|
|
|
// there was an error probing the service.
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered service URL.
|
|
|
|
func NewWANPPPConnection1ClientsByURL(loc *url.URL) ([]*WANPPPConnection1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsByURL(loc, URN_WANPPPConnection_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANPPPConnection1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewWANPPPConnection1ClientsFromRootDevice discovers instances of the service in
|
|
|
|
// a given root device, and returns clients to any that are found. An error is
|
|
|
|
// returned if there was not at least one instance of the service within the
|
|
|
|
// device. The location parameter is simply assigned to the Location attribute
|
|
|
|
// of the wrapped ServiceClient(s).
|
|
|
|
//
|
|
|
|
// This is a typical entry calling point into this package when reusing an
|
|
|
|
// previously discovered root device.
|
|
|
|
func NewWANPPPConnection1ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*WANPPPConnection1, error) {
|
|
|
|
genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, URN_WANPPPConnection_1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return newWANPPPConnection1ClientsFromGenericClients(genericClients), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func newWANPPPConnection1ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*WANPPPConnection1 {
|
|
|
|
clients := make([]*WANPPPConnection1, len(genericClients))
|
|
|
|
for i := range genericClients {
|
|
|
|
clients[i] = &WANPPPConnection1{genericClients[i]}
|
|
|
|
}
|
|
|
|
return clients
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANPPPConnection1) SetConnectionTypeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewConnectionType string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewConnectionType string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewConnectionType, err = soap.MarshalString(NewConnectionType); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "SetConnectionType", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetConnectionType is the legacy version of SetConnectionTypeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) SetConnectionType(NewConnectionType string) (err error) {
|
|
|
|
return client.SetConnectionTypeCtx(context.Background(),
|
|
|
|
NewConnectionType,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewPossibleConnectionTypes: allowed values: Unconfigured, IP_Routed, DHCP_Spoofed, PPPoE_Bridged, PPTP_Relay, L2TP_Relay, PPPoE_Relay
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANPPPConnection1) GetConnectionTypeInfoCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewConnectionType string, NewPossibleConnectionTypes string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewConnectionType string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewPossibleConnectionTypes string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetConnectionTypeInfo", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewConnectionType, err = soap.UnmarshalString(response.NewConnectionType); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewPossibleConnectionTypes, err = soap.UnmarshalString(response.NewPossibleConnectionTypes); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetConnectionTypeInfo is the legacy version of GetConnectionTypeInfoCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetConnectionTypeInfo() (NewConnectionType string, NewPossibleConnectionTypes string, err error) {
|
|
|
|
return client.GetConnectionTypeInfoCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) ConfigureConnectionCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewUserName string,
|
|
|
|
NewPassword string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewUserName string
|
|
|
|
NewPassword string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewUserName, err = soap.MarshalString(NewUserName); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewPassword, err = soap.MarshalString(NewPassword); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "ConfigureConnection", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// ConfigureConnection is the legacy version of ConfigureConnectionCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) ConfigureConnection(NewUserName string, NewPassword string) (err error) {
|
|
|
|
return client.ConfigureConnectionCtx(context.Background(),
|
|
|
|
NewUserName,
|
|
|
|
NewPassword,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) RequestConnectionCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "RequestConnection", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// RequestConnection is the legacy version of RequestConnectionCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) RequestConnection() (err error) {
|
|
|
|
return client.RequestConnectionCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) RequestTerminationCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "RequestTermination", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// RequestTermination is the legacy version of RequestTerminationCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) RequestTermination() (err error) {
|
|
|
|
return client.RequestTerminationCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) ForceTerminationCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "ForceTermination", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// ForceTermination is the legacy version of ForceTerminationCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) ForceTermination() (err error) {
|
|
|
|
return client.ForceTerminationCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) SetAutoDisconnectTimeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewAutoDisconnectTime uint32,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewAutoDisconnectTime string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewAutoDisconnectTime, err = soap.MarshalUi4(NewAutoDisconnectTime); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "SetAutoDisconnectTime", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetAutoDisconnectTime is the legacy version of SetAutoDisconnectTimeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) SetAutoDisconnectTime(NewAutoDisconnectTime uint32) (err error) {
|
|
|
|
return client.SetAutoDisconnectTimeCtx(context.Background(),
|
|
|
|
NewAutoDisconnectTime,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) SetIdleDisconnectTimeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewIdleDisconnectTime uint32,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewIdleDisconnectTime string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewIdleDisconnectTime, err = soap.MarshalUi4(NewIdleDisconnectTime); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "SetIdleDisconnectTime", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetIdleDisconnectTime is the legacy version of SetIdleDisconnectTimeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) SetIdleDisconnectTime(NewIdleDisconnectTime uint32) (err error) {
|
|
|
|
return client.SetIdleDisconnectTimeCtx(context.Background(),
|
|
|
|
NewIdleDisconnectTime,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) SetWarnDisconnectDelayCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewWarnDisconnectDelay uint32,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewWarnDisconnectDelay string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewWarnDisconnectDelay, err = soap.MarshalUi4(NewWarnDisconnectDelay); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "SetWarnDisconnectDelay", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// SetWarnDisconnectDelay is the legacy version of SetWarnDisconnectDelayCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) SetWarnDisconnectDelay(NewWarnDisconnectDelay uint32) (err error) {
|
|
|
|
return client.SetWarnDisconnectDelayCtx(context.Background(),
|
|
|
|
NewWarnDisconnectDelay,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewConnectionStatus: allowed values: Unconfigured, Connected, Disconnected
|
|
|
|
//
|
|
|
|
// * NewLastConnectionError: allowed values: ERROR_NONE
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANPPPConnection1) GetStatusInfoCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewConnectionStatus string, NewLastConnectionError string, NewUptime uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewConnectionStatus string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewLastConnectionError string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewUptime string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetStatusInfo", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewConnectionStatus, err = soap.UnmarshalString(response.NewConnectionStatus); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewLastConnectionError, err = soap.UnmarshalString(response.NewLastConnectionError); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewUptime, err = soap.UnmarshalUi4(response.NewUptime); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetStatusInfo is the legacy version of GetStatusInfoCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetStatusInfo() (NewConnectionStatus string, NewLastConnectionError string, NewUptime uint32, err error) {
|
|
|
|
return client.GetStatusInfoCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) GetLinkLayerMaxBitRatesCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewUpstreamMaxBitRate uint32, NewDownstreamMaxBitRate uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewUpstreamMaxBitRate string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewDownstreamMaxBitRate string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetLinkLayerMaxBitRates", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewUpstreamMaxBitRate, err = soap.UnmarshalUi4(response.NewUpstreamMaxBitRate); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewDownstreamMaxBitRate, err = soap.UnmarshalUi4(response.NewDownstreamMaxBitRate); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetLinkLayerMaxBitRates is the legacy version of GetLinkLayerMaxBitRatesCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetLinkLayerMaxBitRates() (NewUpstreamMaxBitRate uint32, NewDownstreamMaxBitRate uint32, err error) {
|
|
|
|
return client.GetLinkLayerMaxBitRatesCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) GetPPPEncryptionProtocolCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewPPPEncryptionProtocol string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewPPPEncryptionProtocol string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetPPPEncryptionProtocol", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewPPPEncryptionProtocol, err = soap.UnmarshalString(response.NewPPPEncryptionProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetPPPEncryptionProtocol is the legacy version of GetPPPEncryptionProtocolCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetPPPEncryptionProtocol() (NewPPPEncryptionProtocol string, err error) {
|
|
|
|
return client.GetPPPEncryptionProtocolCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) GetPPPCompressionProtocolCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewPPPCompressionProtocol string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewPPPCompressionProtocol string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetPPPCompressionProtocol", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewPPPCompressionProtocol, err = soap.UnmarshalString(response.NewPPPCompressionProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetPPPCompressionProtocol is the legacy version of GetPPPCompressionProtocolCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetPPPCompressionProtocol() (NewPPPCompressionProtocol string, err error) {
|
|
|
|
return client.GetPPPCompressionProtocolCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) GetPPPAuthenticationProtocolCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewPPPAuthenticationProtocol string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewPPPAuthenticationProtocol string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetPPPAuthenticationProtocol", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewPPPAuthenticationProtocol, err = soap.UnmarshalString(response.NewPPPAuthenticationProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetPPPAuthenticationProtocol is the legacy version of GetPPPAuthenticationProtocolCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetPPPAuthenticationProtocol() (NewPPPAuthenticationProtocol string, err error) {
|
|
|
|
return client.GetPPPAuthenticationProtocolCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) GetUserNameCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewUserName string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewUserName string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetUserName", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewUserName, err = soap.UnmarshalString(response.NewUserName); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetUserName is the legacy version of GetUserNameCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetUserName() (NewUserName string, err error) {
|
|
|
|
return client.GetUserNameCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) GetPasswordCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewPassword string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewPassword string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetPassword", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewPassword, err = soap.UnmarshalString(response.NewPassword); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetPassword is the legacy version of GetPasswordCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetPassword() (NewPassword string, err error) {
|
|
|
|
return client.GetPasswordCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) GetAutoDisconnectTimeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewAutoDisconnectTime uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewAutoDisconnectTime string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetAutoDisconnectTime", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewAutoDisconnectTime, err = soap.UnmarshalUi4(response.NewAutoDisconnectTime); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetAutoDisconnectTime is the legacy version of GetAutoDisconnectTimeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetAutoDisconnectTime() (NewAutoDisconnectTime uint32, err error) {
|
|
|
|
return client.GetAutoDisconnectTimeCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) GetIdleDisconnectTimeCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewIdleDisconnectTime uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewIdleDisconnectTime string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetIdleDisconnectTime", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewIdleDisconnectTime, err = soap.UnmarshalUi4(response.NewIdleDisconnectTime); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetIdleDisconnectTime is the legacy version of GetIdleDisconnectTimeCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetIdleDisconnectTime() (NewIdleDisconnectTime uint32, err error) {
|
|
|
|
return client.GetIdleDisconnectTimeCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) GetWarnDisconnectDelayCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewWarnDisconnectDelay uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewWarnDisconnectDelay string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetWarnDisconnectDelay", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewWarnDisconnectDelay, err = soap.UnmarshalUi4(response.NewWarnDisconnectDelay); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetWarnDisconnectDelay is the legacy version of GetWarnDisconnectDelayCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetWarnDisconnectDelay() (NewWarnDisconnectDelay uint32, err error) {
|
|
|
|
return client.GetWarnDisconnectDelayCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) GetNATRSIPStatusCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewRSIPAvailable bool, NewNATEnabled bool, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewRSIPAvailable string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewNATEnabled string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetNATRSIPStatus", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewRSIPAvailable, err = soap.UnmarshalBoolean(response.NewRSIPAvailable); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewNATEnabled, err = soap.UnmarshalBoolean(response.NewNATEnabled); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetNATRSIPStatus is the legacy version of GetNATRSIPStatusCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetNATRSIPStatus() (NewRSIPAvailable bool, NewNATEnabled bool, err error) {
|
|
|
|
return client.GetNATRSIPStatusCtx(context.Background())
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Return values:
|
|
|
|
//
|
|
|
|
// * NewProtocol: allowed values: TCP, UDP
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANPPPConnection1) GetGenericPortMappingEntryCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewPortMappingIndex uint16,
|
|
|
|
) (NewRemoteHost string, NewExternalPort uint16, NewProtocol string, NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
|
|
|
NewPortMappingIndex string
|
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewPortMappingIndex, err = soap.MarshalUi2(NewPortMappingIndex); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewPortMappingDescription string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewLeaseDuration string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetGenericPortMappingEntry", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewRemoteHost, err = soap.UnmarshalString(response.NewRemoteHost); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewExternalPort, err = soap.UnmarshalUi2(response.NewExternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewProtocol, err = soap.UnmarshalString(response.NewProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewInternalPort, err = soap.UnmarshalUi2(response.NewInternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewInternalClient, err = soap.UnmarshalString(response.NewInternalClient); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewEnabled, err = soap.UnmarshalBoolean(response.NewEnabled); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewPortMappingDescription, err = soap.UnmarshalString(response.NewPortMappingDescription); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewLeaseDuration, err = soap.UnmarshalUi4(response.NewLeaseDuration); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetGenericPortMappingEntry is the legacy version of GetGenericPortMappingEntryCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetGenericPortMappingEntry(NewPortMappingIndex uint16) (NewRemoteHost string, NewExternalPort uint16, NewProtocol string, NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
|
|
|
return client.GetGenericPortMappingEntryCtx(context.Background(),
|
|
|
|
NewPortMappingIndex,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Arguments:
|
|
|
|
//
|
|
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANPPPConnection1) GetSpecificPortMappingEntryCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewRemoteHost string,
|
|
|
|
NewExternalPort uint16,
|
|
|
|
NewProtocol string,
|
|
|
|
) (NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewRemoteHost string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewExternalPort string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewProtocol string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewRemoteHost, err = soap.MarshalString(NewRemoteHost); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewExternalPort, err = soap.MarshalUi2(NewExternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewProtocol, err = soap.MarshalString(NewProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewPortMappingDescription string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewLeaseDuration string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetSpecificPortMappingEntry", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewInternalPort, err = soap.UnmarshalUi2(response.NewInternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewInternalClient, err = soap.UnmarshalString(response.NewInternalClient); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewEnabled, err = soap.UnmarshalBoolean(response.NewEnabled); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewPortMappingDescription, err = soap.UnmarshalString(response.NewPortMappingDescription); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if NewLeaseDuration, err = soap.UnmarshalUi4(response.NewLeaseDuration); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// GetSpecificPortMappingEntry is the legacy version of GetSpecificPortMappingEntryCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetSpecificPortMappingEntry(NewRemoteHost string, NewExternalPort uint16, NewProtocol string) (NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
|
|
|
return client.GetSpecificPortMappingEntryCtx(context.Background(),
|
|
|
|
NewRemoteHost,
|
|
|
|
NewExternalPort,
|
|
|
|
NewProtocol,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Arguments:
|
|
|
|
//
|
|
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANPPPConnection1) AddPortMappingCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewRemoteHost string,
|
|
|
|
NewExternalPort uint16,
|
|
|
|
NewProtocol string,
|
|
|
|
NewInternalPort uint16,
|
|
|
|
NewInternalClient string,
|
|
|
|
NewEnabled bool,
|
|
|
|
NewPortMappingDescription string,
|
|
|
|
NewLeaseDuration uint32,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewPortMappingDescription string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewLeaseDuration string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewRemoteHost, err = soap.MarshalString(NewRemoteHost); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewExternalPort, err = soap.MarshalUi2(NewExternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewProtocol, err = soap.MarshalString(NewProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewInternalPort, err = soap.MarshalUi2(NewInternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewInternalClient, err = soap.MarshalString(NewInternalClient); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewEnabled, err = soap.MarshalBoolean(NewEnabled); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewPortMappingDescription, err = soap.MarshalString(NewPortMappingDescription); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewLeaseDuration, err = soap.MarshalUi4(NewLeaseDuration); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "AddPortMapping", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// AddPortMapping is the legacy version of AddPortMappingCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) AddPortMapping(NewRemoteHost string, NewExternalPort uint16, NewProtocol string, NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32) (err error) {
|
|
|
|
return client.AddPortMappingCtx(context.Background(),
|
|
|
|
NewRemoteHost,
|
|
|
|
NewExternalPort,
|
|
|
|
NewProtocol,
|
|
|
|
NewInternalPort,
|
|
|
|
NewInternalClient,
|
|
|
|
NewEnabled,
|
|
|
|
NewPortMappingDescription,
|
|
|
|
NewLeaseDuration,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2016-06-14 16:17:44 +00:00
|
|
|
//
|
|
|
|
// Arguments:
|
|
|
|
//
|
|
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
func (client *WANPPPConnection1) DeletePortMappingCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
NewRemoteHost string,
|
|
|
|
NewExternalPort uint16,
|
|
|
|
NewProtocol string,
|
|
|
|
) (err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := &struct {
|
2019-06-09 07:24:20 +00:00
|
|
|
NewRemoteHost string
|
2016-06-14 16:17:44 +00:00
|
|
|
NewExternalPort string
|
2019-06-09 07:24:20 +00:00
|
|
|
NewProtocol string
|
2016-06-14 16:17:44 +00:00
|
|
|
}{}
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
if request.NewRemoteHost, err = soap.MarshalString(NewRemoteHost); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewExternalPort, err = soap.MarshalUi2(NewExternalPort); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if request.NewProtocol, err = soap.MarshalString(NewProtocol); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := interface{}(nil)
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "DeletePortMapping", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-10-19 13:43:41 +00:00
|
|
|
// DeletePortMapping is the legacy version of DeletePortMappingCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) DeletePortMapping(NewRemoteHost string, NewExternalPort uint16, NewProtocol string) (err error) {
|
|
|
|
return client.DeletePortMappingCtx(context.Background(),
|
|
|
|
NewRemoteHost,
|
|
|
|
NewExternalPort,
|
|
|
|
NewProtocol,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *WANPPPConnection1) GetExternalIPAddressCtx(
|
|
|
|
ctx context.Context,
|
|
|
|
) (NewExternalIPAddress string, err error) {
|
2016-06-14 16:17:44 +00:00
|
|
|
// Request structure.
|
|
|
|
request := interface{}(nil)
|
|
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
|
|
|
|
// Response structure.
|
|
|
|
response := &struct {
|
|
|
|
NewExternalIPAddress string
|
|
|
|
}{}
|
|
|
|
|
|
|
|
// Perform the SOAP call.
|
2021-10-19 13:43:41 +00:00
|
|
|
if err = client.SOAPClient.PerformActionCtx(ctx, URN_WANPPPConnection_1, "GetExternalIPAddress", request, response); err != nil {
|
2016-06-14 16:17:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
|
|
|
|
if NewExternalIPAddress, err = soap.UnmarshalString(response.NewExternalIPAddress); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// END Unmarshal arguments from response.
|
|
|
|
return
|
|
|
|
}
|
2021-10-19 13:43:41 +00:00
|
|
|
|
|
|
|
// GetExternalIPAddress is the legacy version of GetExternalIPAddressCtx, but uses
|
|
|
|
// context.Background() as the context.
|
|
|
|
func (client *WANPPPConnection1) GetExternalIPAddress() (NewExternalIPAddress string, err error) {
|
|
|
|
return client.GetExternalIPAddressCtx(context.Background())
|
|
|
|
}
|