289b30715d
This commit converts the dependency management from Godeps to the vendor folder, also switching the tool from godep to trash. Since the upstream tool lacks a few features proposed via a few PRs, until those PRs are merged in (if), use github.com/karalabe/trash. You can update dependencies via trash --update. All dependencies have been updated to their latest version. Parts of the build system are reworked to drop old notions of Godeps and invocation of the go vet command so that it doesn't run against the vendor folder, as that will just blow up during vetting. The conversion drops OpenCL (and hence GPU mining support) from ethash and our codebase. The short reasoning is that there's noone to maintain and having opencl libs in our deps messes up builds as go install ./... tries to build them, failing with unsatisfied link errors for the C OpenCL deps. golang.org/x/net/context is not vendored in. We expect it to be fetched by the user (i.e. using go get). To keep ci.go builds reproducible the package is "vendored" in build/_vendor.
3718 lines
107 KiB
Go
3718 lines
107 KiB
Go
// 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
|
|
|
|
// Generated file - do not edit by hand. See README.md
|
|
|
|
import (
|
|
"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
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) SetDHCPServerConfigurable(NewDHCPServerConfigurable bool) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "SetDHCPServerConfigurable", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) GetDHCPServerConfigurable() (NewDHCPServerConfigurable bool, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "GetDHCPServerConfigurable", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewDHCPServerConfigurable, err = soap.UnmarshalBoolean(response.NewDHCPServerConfigurable); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) SetDHCPRelay(NewDHCPRelay bool) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "SetDHCPRelay", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) GetDHCPRelay() (NewDHCPRelay bool, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "GetDHCPRelay", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewDHCPRelay, err = soap.UnmarshalBoolean(response.NewDHCPRelay); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) SetSubnetMask(NewSubnetMask string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "SetSubnetMask", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) GetSubnetMask() (NewSubnetMask string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "GetSubnetMask", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewSubnetMask, err = soap.UnmarshalString(response.NewSubnetMask); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) SetIPRouter(NewIPRouters string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "SetIPRouter", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) DeleteIPRouter(NewIPRouters string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "DeleteIPRouter", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) GetIPRoutersList() (NewIPRouters string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "GetIPRoutersList", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewIPRouters, err = soap.UnmarshalString(response.NewIPRouters); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) SetDomainName(NewDomainName string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "SetDomainName", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) GetDomainName() (NewDomainName string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "GetDomainName", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewDomainName, err = soap.UnmarshalString(response.NewDomainName); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) SetAddressRange(NewMinAddress string, NewMaxAddress string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "SetAddressRange", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) GetAddressRange() (NewMinAddress string, NewMaxAddress string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "GetAddressRange", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) SetReservedAddress(NewReservedAddresses string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "SetReservedAddress", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) DeleteReservedAddress(NewReservedAddresses string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "DeleteReservedAddress", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) GetReservedAddresses() (NewReservedAddresses string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "GetReservedAddresses", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewReservedAddresses, err = soap.UnmarshalString(response.NewReservedAddresses); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) SetDNSServer(NewDNSServers string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "SetDNSServer", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) DeleteDNSServer(NewDNSServers string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "DeleteDNSServer", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *LANHostConfigManagement1) GetDNSServers() (NewDNSServers string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_LANHostConfigManagement_1, "GetDNSServers", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewDNSServers, err = soap.UnmarshalString(response.NewDNSServers); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
func (client *Layer3Forwarding1) SetDefaultConnectionService(NewDefaultConnectionService string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_Layer3Forwarding_1, "SetDefaultConnectionService", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *Layer3Forwarding1) GetDefaultConnectionService() (NewDefaultConnectionService string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_Layer3Forwarding_1, "GetDefaultConnectionService", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewDefaultConnectionService, err = soap.UnmarshalString(response.NewDefaultConnectionService); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
// 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
|
|
func (client *WANCableLinkConfig1) GetCableLinkConfigInfo() (NewCableLinkConfigState string, NewLinkType string, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewCableLinkConfigState string
|
|
|
|
NewLinkType string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCableLinkConfig_1, "GetCableLinkConfigInfo", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
func (client *WANCableLinkConfig1) GetDownstreamFrequency() (NewDownstreamFrequency uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCableLinkConfig_1, "GetDownstreamFrequency", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewDownstreamFrequency, err = soap.UnmarshalUi4(response.NewDownstreamFrequency); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewDownstreamModulation: allowed values: 64QAM, 256QAM
|
|
func (client *WANCableLinkConfig1) GetDownstreamModulation() (NewDownstreamModulation string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCableLinkConfig_1, "GetDownstreamModulation", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewDownstreamModulation, err = soap.UnmarshalString(response.NewDownstreamModulation); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCableLinkConfig1) GetUpstreamFrequency() (NewUpstreamFrequency uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCableLinkConfig_1, "GetUpstreamFrequency", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewUpstreamFrequency, err = soap.UnmarshalUi4(response.NewUpstreamFrequency); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewUpstreamModulation: allowed values: QPSK, 16QAM
|
|
func (client *WANCableLinkConfig1) GetUpstreamModulation() (NewUpstreamModulation string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCableLinkConfig_1, "GetUpstreamModulation", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewUpstreamModulation, err = soap.UnmarshalString(response.NewUpstreamModulation); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCableLinkConfig1) GetUpstreamChannelID() (NewUpstreamChannelID uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCableLinkConfig_1, "GetUpstreamChannelID", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewUpstreamChannelID, err = soap.UnmarshalUi4(response.NewUpstreamChannelID); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCableLinkConfig1) GetUpstreamPowerLevel() (NewUpstreamPowerLevel uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCableLinkConfig_1, "GetUpstreamPowerLevel", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewUpstreamPowerLevel, err = soap.UnmarshalUi4(response.NewUpstreamPowerLevel); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCableLinkConfig1) GetBPIEncryptionEnabled() (NewBPIEncryptionEnabled bool, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCableLinkConfig_1, "GetBPIEncryptionEnabled", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewBPIEncryptionEnabled, err = soap.UnmarshalBoolean(response.NewBPIEncryptionEnabled); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCableLinkConfig1) GetConfigFile() (NewConfigFile string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCableLinkConfig_1, "GetConfigFile", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewConfigFile, err = soap.UnmarshalString(response.NewConfigFile); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCableLinkConfig1) GetTFTPServer() (NewTFTPServer string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCableLinkConfig_1, "GetTFTPServer", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewTFTPServer, err = soap.UnmarshalString(response.NewTFTPServer); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
func (client *WANCommonInterfaceConfig1) SetEnabledForInternet(NewEnabledForInternet bool) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCommonInterfaceConfig_1, "SetEnabledForInternet", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetEnabledForInternet() (NewEnabledForInternet bool, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCommonInterfaceConfig_1, "GetEnabledForInternet", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewEnabledForInternet, err = soap.UnmarshalBoolean(response.NewEnabledForInternet); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewWANAccessType: allowed values: DSL, POTS, Cable, Ethernet
|
|
//
|
|
// * NewPhysicalLinkStatus: allowed values: Up, Down
|
|
func (client *WANCommonInterfaceConfig1) GetCommonLinkProperties() (NewWANAccessType string, NewLayer1UpstreamMaxBitRate uint32, NewLayer1DownstreamMaxBitRate uint32, NewPhysicalLinkStatus string, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewWANAccessType string
|
|
|
|
NewLayer1UpstreamMaxBitRate string
|
|
|
|
NewLayer1DownstreamMaxBitRate string
|
|
|
|
NewPhysicalLinkStatus string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCommonInterfaceConfig_1, "GetCommonLinkProperties", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetWANAccessProvider() (NewWANAccessProvider string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCommonInterfaceConfig_1, "GetWANAccessProvider", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewWANAccessProvider, err = soap.UnmarshalString(response.NewWANAccessProvider); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewMaximumActiveConnections: allowed value range: minimum=1, step=1
|
|
func (client *WANCommonInterfaceConfig1) GetMaximumActiveConnections() (NewMaximumActiveConnections uint16, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCommonInterfaceConfig_1, "GetMaximumActiveConnections", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewMaximumActiveConnections, err = soap.UnmarshalUi2(response.NewMaximumActiveConnections); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalBytesSent() (NewTotalBytesSent uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCommonInterfaceConfig_1, "GetTotalBytesSent", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewTotalBytesSent, err = soap.UnmarshalUi4(response.NewTotalBytesSent); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalBytesReceived() (NewTotalBytesReceived uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCommonInterfaceConfig_1, "GetTotalBytesReceived", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewTotalBytesReceived, err = soap.UnmarshalUi4(response.NewTotalBytesReceived); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalPacketsSent() (NewTotalPacketsSent uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCommonInterfaceConfig_1, "GetTotalPacketsSent", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewTotalPacketsSent, err = soap.UnmarshalUi4(response.NewTotalPacketsSent); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetTotalPacketsReceived() (NewTotalPacketsReceived uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCommonInterfaceConfig_1, "GetTotalPacketsReceived", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewTotalPacketsReceived, err = soap.UnmarshalUi4(response.NewTotalPacketsReceived); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANCommonInterfaceConfig1) GetActiveConnection(NewActiveConnectionIndex uint16) (NewActiveConnDeviceContainer string, NewActiveConnectionServiceID string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANCommonInterfaceConfig_1, "GetActiveConnection", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
func (client *WANDSLLinkConfig1) SetDSLLinkType(NewLinkType string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANDSLLinkConfig_1, "SetDSLLinkType", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewLinkStatus: allowed values: Up, Down
|
|
func (client *WANDSLLinkConfig1) GetDSLLinkInfo() (NewLinkType string, NewLinkStatus string, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewLinkType string
|
|
|
|
NewLinkStatus string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANDSLLinkConfig_1, "GetDSLLinkInfo", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
func (client *WANDSLLinkConfig1) GetAutoConfig() (NewAutoConfig bool, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANDSLLinkConfig_1, "GetAutoConfig", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewAutoConfig, err = soap.UnmarshalBoolean(response.NewAutoConfig); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANDSLLinkConfig1) GetModulationType() (NewModulationType string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANDSLLinkConfig_1, "GetModulationType", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewModulationType, err = soap.UnmarshalString(response.NewModulationType); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANDSLLinkConfig1) SetDestinationAddress(NewDestinationAddress string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANDSLLinkConfig_1, "SetDestinationAddress", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANDSLLinkConfig1) GetDestinationAddress() (NewDestinationAddress string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANDSLLinkConfig_1, "GetDestinationAddress", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewDestinationAddress, err = soap.UnmarshalString(response.NewDestinationAddress); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANDSLLinkConfig1) SetATMEncapsulation(NewATMEncapsulation string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANDSLLinkConfig_1, "SetATMEncapsulation", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANDSLLinkConfig1) GetATMEncapsulation() (NewATMEncapsulation string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANDSLLinkConfig_1, "GetATMEncapsulation", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewATMEncapsulation, err = soap.UnmarshalString(response.NewATMEncapsulation); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANDSLLinkConfig1) SetFCSPreserved(NewFCSPreserved bool) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANDSLLinkConfig_1, "SetFCSPreserved", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANDSLLinkConfig1) GetFCSPreserved() (NewFCSPreserved bool, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANDSLLinkConfig_1, "GetFCSPreserved", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewFCSPreserved, err = soap.UnmarshalBoolean(response.NewFCSPreserved); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
// 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
|
|
func (client *WANEthernetLinkConfig1) GetEthernetLinkStatus() (NewEthernetLinkStatus string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANEthernetLinkConfig_1, "GetEthernetLinkStatus", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewEthernetLinkStatus, err = soap.UnmarshalString(response.NewEthernetLinkStatus); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
func (client *WANIPConnection1) SetConnectionType(NewConnectionType string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "SetConnectionType", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewPossibleConnectionTypes: allowed values: Unconfigured, IP_Routed, IP_Bridged
|
|
func (client *WANIPConnection1) GetConnectionTypeInfo() (NewConnectionType string, NewPossibleConnectionTypes string, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewConnectionType string
|
|
|
|
NewPossibleConnectionTypes string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "GetConnectionTypeInfo", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
func (client *WANIPConnection1) RequestConnection() (err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := interface{}(nil)
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "RequestConnection", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANIPConnection1) RequestTermination() (err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := interface{}(nil)
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "RequestTermination", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANIPConnection1) ForceTermination() (err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := interface{}(nil)
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "ForceTermination", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANIPConnection1) SetAutoDisconnectTime(NewAutoDisconnectTime uint32) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "SetAutoDisconnectTime", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANIPConnection1) SetIdleDisconnectTime(NewIdleDisconnectTime uint32) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "SetIdleDisconnectTime", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANIPConnection1) SetWarnDisconnectDelay(NewWarnDisconnectDelay uint32) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "SetWarnDisconnectDelay", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewConnectionStatus: allowed values: Unconfigured, Connected, Disconnected
|
|
//
|
|
// * NewLastConnectionError: allowed values: ERROR_NONE
|
|
func (client *WANIPConnection1) GetStatusInfo() (NewConnectionStatus string, NewLastConnectionError string, NewUptime uint32, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewConnectionStatus string
|
|
|
|
NewLastConnectionError string
|
|
|
|
NewUptime string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "GetStatusInfo", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
func (client *WANIPConnection1) GetAutoDisconnectTime() (NewAutoDisconnectTime uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "GetAutoDisconnectTime", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewAutoDisconnectTime, err = soap.UnmarshalUi4(response.NewAutoDisconnectTime); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANIPConnection1) GetIdleDisconnectTime() (NewIdleDisconnectTime uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "GetIdleDisconnectTime", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewIdleDisconnectTime, err = soap.UnmarshalUi4(response.NewIdleDisconnectTime); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANIPConnection1) GetWarnDisconnectDelay() (NewWarnDisconnectDelay uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "GetWarnDisconnectDelay", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewWarnDisconnectDelay, err = soap.UnmarshalUi4(response.NewWarnDisconnectDelay); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANIPConnection1) GetNATRSIPStatus() (NewRSIPAvailable bool, NewNATEnabled bool, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewRSIPAvailable string
|
|
|
|
NewNATEnabled string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "GetNATRSIPStatus", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
func (client *WANIPConnection1) GetGenericPortMappingEntry(NewPortMappingIndex uint16) (NewRemoteHost string, NewExternalPort uint16, NewProtocol string, NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
|
// 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 {
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
|
|
|
NewPortMappingDescription string
|
|
|
|
NewLeaseDuration string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "GetGenericPortMappingEntry", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
//
|
|
// Arguments:
|
|
//
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
func (client *WANIPConnection1) GetSpecificPortMappingEntry(NewRemoteHost string, NewExternalPort uint16, NewProtocol string) (NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
|
// Request structure.
|
|
request := &struct {
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
}{}
|
|
// 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 {
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
|
|
|
NewPortMappingDescription string
|
|
|
|
NewLeaseDuration string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "GetSpecificPortMappingEntry", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
//
|
|
// Arguments:
|
|
//
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
func (client *WANIPConnection1) AddPortMapping(NewRemoteHost string, NewExternalPort uint16, NewProtocol string, NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32) (err error) {
|
|
// Request structure.
|
|
request := &struct {
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
|
|
|
NewPortMappingDescription string
|
|
|
|
NewLeaseDuration string
|
|
}{}
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "AddPortMapping", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Arguments:
|
|
//
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
func (client *WANIPConnection1) DeletePortMapping(NewRemoteHost string, NewExternalPort uint16, NewProtocol string) (err error) {
|
|
// Request structure.
|
|
request := &struct {
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
}{}
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "DeletePortMapping", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANIPConnection1) GetExternalIPAddress() (NewExternalIPAddress string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANIPConnection_1, "GetExternalIPAddress", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewExternalIPAddress, err = soap.UnmarshalString(response.NewExternalIPAddress); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
// 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
|
|
|
|
func (client *WANPOTSLinkConfig1) SetISPInfo(NewISPPhoneNumber string, NewISPInfo string, NewLinkType string) (err error) {
|
|
// Request structure.
|
|
request := &struct {
|
|
NewISPPhoneNumber string
|
|
|
|
NewISPInfo string
|
|
|
|
NewLinkType string
|
|
}{}
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPOTSLinkConfig_1, "SetISPInfo", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPOTSLinkConfig1) SetCallRetryInfo(NewNumberOfRetries uint32, NewDelayBetweenRetries uint32) (err error) {
|
|
// Request structure.
|
|
request := &struct {
|
|
NewNumberOfRetries string
|
|
|
|
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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPOTSLinkConfig_1, "SetCallRetryInfo", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewLinkType: allowed values: PPP_Dialup
|
|
func (client *WANPOTSLinkConfig1) GetISPInfo() (NewISPPhoneNumber string, NewISPInfo string, NewLinkType string, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewISPPhoneNumber string
|
|
|
|
NewISPInfo string
|
|
|
|
NewLinkType string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPOTSLinkConfig_1, "GetISPInfo", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
func (client *WANPOTSLinkConfig1) GetCallRetryInfo() (NewNumberOfRetries uint32, NewDelayBetweenRetries uint32, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewNumberOfRetries string
|
|
|
|
NewDelayBetweenRetries string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPOTSLinkConfig_1, "GetCallRetryInfo", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
func (client *WANPOTSLinkConfig1) GetFclass() (NewFclass string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPOTSLinkConfig_1, "GetFclass", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewFclass, err = soap.UnmarshalString(response.NewFclass); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPOTSLinkConfig1) GetDataModulationSupported() (NewDataModulationSupported string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPOTSLinkConfig_1, "GetDataModulationSupported", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewDataModulationSupported, err = soap.UnmarshalString(response.NewDataModulationSupported); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPOTSLinkConfig1) GetDataProtocol() (NewDataProtocol string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPOTSLinkConfig_1, "GetDataProtocol", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewDataProtocol, err = soap.UnmarshalString(response.NewDataProtocol); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPOTSLinkConfig1) GetDataCompression() (NewDataCompression string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPOTSLinkConfig_1, "GetDataCompression", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewDataCompression, err = soap.UnmarshalString(response.NewDataCompression); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPOTSLinkConfig1) GetPlusVTRCommandSupported() (NewPlusVTRCommandSupported bool, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPOTSLinkConfig_1, "GetPlusVTRCommandSupported", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewPlusVTRCommandSupported, err = soap.UnmarshalBoolean(response.NewPlusVTRCommandSupported); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
func (client *WANPPPConnection1) SetConnectionType(NewConnectionType string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "SetConnectionType", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewPossibleConnectionTypes: allowed values: Unconfigured, IP_Routed, DHCP_Spoofed, PPPoE_Bridged, PPTP_Relay, L2TP_Relay, PPPoE_Relay
|
|
func (client *WANPPPConnection1) GetConnectionTypeInfo() (NewConnectionType string, NewPossibleConnectionTypes string, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewConnectionType string
|
|
|
|
NewPossibleConnectionTypes string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetConnectionTypeInfo", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
func (client *WANPPPConnection1) ConfigureConnection(NewUserName string, NewPassword string) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "ConfigureConnection", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) RequestConnection() (err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := interface{}(nil)
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "RequestConnection", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) RequestTermination() (err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := interface{}(nil)
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "RequestTermination", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) ForceTermination() (err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := interface{}(nil)
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "ForceTermination", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) SetAutoDisconnectTime(NewAutoDisconnectTime uint32) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "SetAutoDisconnectTime", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) SetIdleDisconnectTime(NewIdleDisconnectTime uint32) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "SetIdleDisconnectTime", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) SetWarnDisconnectDelay(NewWarnDisconnectDelay uint32) (err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "SetWarnDisconnectDelay", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewConnectionStatus: allowed values: Unconfigured, Connected, Disconnected
|
|
//
|
|
// * NewLastConnectionError: allowed values: ERROR_NONE
|
|
func (client *WANPPPConnection1) GetStatusInfo() (NewConnectionStatus string, NewLastConnectionError string, NewUptime uint32, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewConnectionStatus string
|
|
|
|
NewLastConnectionError string
|
|
|
|
NewUptime string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetStatusInfo", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
func (client *WANPPPConnection1) GetLinkLayerMaxBitRates() (NewUpstreamMaxBitRate uint32, NewDownstreamMaxBitRate uint32, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewUpstreamMaxBitRate string
|
|
|
|
NewDownstreamMaxBitRate string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetLinkLayerMaxBitRates", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
func (client *WANPPPConnection1) GetPPPEncryptionProtocol() (NewPPPEncryptionProtocol string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetPPPEncryptionProtocol", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewPPPEncryptionProtocol, err = soap.UnmarshalString(response.NewPPPEncryptionProtocol); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) GetPPPCompressionProtocol() (NewPPPCompressionProtocol string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetPPPCompressionProtocol", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewPPPCompressionProtocol, err = soap.UnmarshalString(response.NewPPPCompressionProtocol); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) GetPPPAuthenticationProtocol() (NewPPPAuthenticationProtocol string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetPPPAuthenticationProtocol", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewPPPAuthenticationProtocol, err = soap.UnmarshalString(response.NewPPPAuthenticationProtocol); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) GetUserName() (NewUserName string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetUserName", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewUserName, err = soap.UnmarshalString(response.NewUserName); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) GetPassword() (NewPassword string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetPassword", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewPassword, err = soap.UnmarshalString(response.NewPassword); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) GetAutoDisconnectTime() (NewAutoDisconnectTime uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetAutoDisconnectTime", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewAutoDisconnectTime, err = soap.UnmarshalUi4(response.NewAutoDisconnectTime); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) GetIdleDisconnectTime() (NewIdleDisconnectTime uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetIdleDisconnectTime", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewIdleDisconnectTime, err = soap.UnmarshalUi4(response.NewIdleDisconnectTime); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) GetWarnDisconnectDelay() (NewWarnDisconnectDelay uint32, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetWarnDisconnectDelay", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewWarnDisconnectDelay, err = soap.UnmarshalUi4(response.NewWarnDisconnectDelay); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) GetNATRSIPStatus() (NewRSIPAvailable bool, NewNATEnabled bool, err error) {
|
|
// Request structure.
|
|
request := interface{}(nil)
|
|
// BEGIN Marshal arguments into request.
|
|
|
|
// END Marshal arguments into request.
|
|
|
|
// Response structure.
|
|
response := &struct {
|
|
NewRSIPAvailable string
|
|
|
|
NewNATEnabled string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetNATRSIPStatus", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
//
|
|
// Return values:
|
|
//
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
func (client *WANPPPConnection1) GetGenericPortMappingEntry(NewPortMappingIndex uint16) (NewRemoteHost string, NewExternalPort uint16, NewProtocol string, NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
|
// 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 {
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
|
|
|
NewPortMappingDescription string
|
|
|
|
NewLeaseDuration string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetGenericPortMappingEntry", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
//
|
|
// Arguments:
|
|
//
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
func (client *WANPPPConnection1) GetSpecificPortMappingEntry(NewRemoteHost string, NewExternalPort uint16, NewProtocol string) (NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32, err error) {
|
|
// Request structure.
|
|
request := &struct {
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
}{}
|
|
// 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 {
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
|
|
|
NewPortMappingDescription string
|
|
|
|
NewLeaseDuration string
|
|
}{}
|
|
|
|
// Perform the SOAP call.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetSpecificPortMappingEntry", request, response); err != nil {
|
|
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
|
|
}
|
|
|
|
//
|
|
// Arguments:
|
|
//
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
func (client *WANPPPConnection1) AddPortMapping(NewRemoteHost string, NewExternalPort uint16, NewProtocol string, NewInternalPort uint16, NewInternalClient string, NewEnabled bool, NewPortMappingDescription string, NewLeaseDuration uint32) (err error) {
|
|
// Request structure.
|
|
request := &struct {
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
|
|
NewInternalPort string
|
|
|
|
NewInternalClient string
|
|
|
|
NewEnabled string
|
|
|
|
NewPortMappingDescription string
|
|
|
|
NewLeaseDuration string
|
|
}{}
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "AddPortMapping", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
//
|
|
// Arguments:
|
|
//
|
|
// * NewProtocol: allowed values: TCP, UDP
|
|
|
|
func (client *WANPPPConnection1) DeletePortMapping(NewRemoteHost string, NewExternalPort uint16, NewProtocol string) (err error) {
|
|
// Request structure.
|
|
request := &struct {
|
|
NewRemoteHost string
|
|
|
|
NewExternalPort string
|
|
|
|
NewProtocol string
|
|
}{}
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "DeletePortMapping", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|
|
|
|
func (client *WANPPPConnection1) GetExternalIPAddress() (NewExternalIPAddress string, err error) {
|
|
// 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.
|
|
if err = client.SOAPClient.PerformAction(URN_WANPPPConnection_1, "GetExternalIPAddress", request, response); err != nil {
|
|
return
|
|
}
|
|
|
|
// BEGIN Unmarshal arguments from response.
|
|
|
|
if NewExternalIPAddress, err = soap.UnmarshalString(response.NewExternalIPAddress); err != nil {
|
|
return
|
|
}
|
|
// END Unmarshal arguments from response.
|
|
return
|
|
}
|