ONVIF:...icePort(3pm)

📦

version 1.36.37 · 5 versions

1.36.37 · ubuntu resolute, ubuntu stonking (latest)
1.36.12 · ubuntu jammy
1.36.33 · ubuntu noble
1.36.33 · debian bookworm
1.36.35 · debian trixie, ubuntu questing

, in ubuntu resolute, ubuntu stonking

💖 ONVIF::Device::Interfaces::Device::DevicePort(3pm) 💖

(User Contributed Perl Documentation, but make it cute)

✨ NAME ✨

ONVIF::Device::Interfaces::Device::DevicePort — it's the SOAP interface for the Device Web Service, no cap. 💅

🌸 SYNOPSIS 🌸

okay bestie, here's how you summon it:

use ONVIF::Device::Interfaces::Device::DevicePort;
my $interface = ONVIF::Device::Interfaces::Device::DevicePort->new();

my $response;
$response = $interface->GetServices();
$response = $interface->GetServiceCapabilities();
$response = $interface->GetDeviceInformation();
$response = $interface->SetSystemDateAndTime();
$response = $interface->GetSystemDateAndTime();
$response = $interface->SetSystemFactoryDefault();
$response = $interface->UpgradeSystemFirmware();
$response = $interface->SystemReboot();
$response = $interface->RestoreSystem();
$response = $interface->GetSystemBackup();
$response = $interface->GetSystemLog();
$response = $interface->GetSystemSupportInformation();
$response = $interface->GetScopes();
$response = $interface->SetScopes();
$response = $interface->AddScopes();
$response = $interface->RemoveScopes();
$response = $interface->GetDiscoveryMode();
$response = $interface->SetDiscoveryMode();
$response = $interface->GetRemoteDiscoveryMode();
$response = $interface->SetRemoteDiscoveryMode();
$response = $interface->GetDPAddresses();
$response = $interface->GetEndpointReference();
$response = $interface->GetRemoteUser();
$response = $interface->SetRemoteUser();
$response = $interface->GetUsers();
$response = $interface->CreateUsers();
$response = $interface->DeleteUsers();
$response = $interface->SetUser();
$response = $interface->GetWsdlUrl();
$response = $interface->GetCapabilities();
$response = $interface->SetDPAddresses();
$response = $interface->GetHostname();
$response = $interface->SetHostname();
$response = $interface->SetHostnameFromDHCP();
$response = $interface->GetDNS();
$response = $interface->SetDNS();
$response = $interface->GetNTP();
$response = $interface->SetNTP();
$response = $interface->GetDynamicDNS();
$response = $interface->SetDynamicDNS();
$response = $interface->GetNetworkInterfaces();
$response = $interface->SetNetworkInterfaces();
$response = $interface->GetNetworkProtocols();
$response = $interface->SetNetworkProtocols();
$response = $interface->GetNetworkDefaultGateway();
$response = $interface->SetNetworkDefaultGateway();
$response = $interface->GetZeroConfiguration();
$response = $interface->SetZeroConfiguration();
$response = $interface->GetIPAddressFilter();
$response = $interface->SetIPAddressFilter();
$response = $interface->AddIPAddressFilter();
$response = $interface->RemoveIPAddressFilter();
$response = $interface->GetAccessPolicy();
$response = $interface->SetAccessPolicy();
$response = $interface->CreateCertificate();
$response = $interface->GetCertificates();
$response = $interface->GetCertificatesStatus();
$response = $interface->SetCertificatesStatus();
$response = $interface->DeleteCertificates();
$response = $interface->GetPkcs10Request();
$response = $interface->LoadCertificates();
$response = $interface->GetClientCertificateMode();
$response = $interface->SetClientCertificateMode();
$response = $interface->GetRelayOutputs();
$response = $interface->SetRelayOutputSettings();
$response = $interface->SetRelayOutputState();
$response = $interface->SendAuxiliaryCommand();
$response = $interface->GetCACertificates();
$response = $interface->LoadCertificateWithPrivateKey();
$response = $interface->GetCertificateInformation();
$response = $interface->LoadCACertificates();
$response = $interface->CreateDot1XConfiguration();
$response = $interface->SetDot1XConfiguration();
$response = $interface->GetDot1XConfiguration();
$response = $interface->GetDot1XConfigurations();
$response = $interface->DeleteDot1XConfiguration();
$response = $interface->GetDot11Capabilities();
$response = $interface->GetDot11Status();
$response = $interface->ScanAvailableDot11Networks();
$response = $interface->GetSystemUris();
$response = $interface->StartFirmwareUpgrade();
$response = $interface->StartSystemRestore();

💖 DESCRIPTION 💖

It's the SOAP interface for the Device web service, and it's posted up at http://www.examples.com/Device/. 🫶

🎀 SERVICE Device 🎀

🦋 Port DevicePort 🦋

👑 METHODS 👑

🌈 General methods 🌈

💅 new 💅

It's the constructor, bestie. Every single argument gets forwarded straight to SOAP::WSDL::Client, periodt. 💅

⭐ SOAP Service methods ⭐

So the method synopsis? It shows up with hash refs as the parameters, iykyk.

Those commented class names inside the method's parameters? They're literally telling you that objects of the corresponding class can be passed instead of the marked hash ref. iconic.

You can pass any combo of objects, hash and list refs to these methods — just make sure you meet the structure, okay? 🦋

List items (aka multiple occurrences) are not displayed in the synopsis. You can usually pass a list ref of hash refs (or objects) instead of a hash ref — but lowkey, this may result in invalid XML if you use it improperly, so be careful. Also note that SOAP::WSDL always expects list references at maximum depth position. no cap.

XML attributes? They're not displayed in this synopsis and cannot be set using hash refs. Check the respective class' documentation for the extra tea. 💅

🔥 GetServices 🔥

It returns info about the services chillin' on the device. 🫶

It hands you back a ONVIF::Device::Elements::GetServicesResponse object. 💖

 $response = $interface->GetServices( {
   IncludeCapability =>  $some_value, # boolean
 },,
);

✨ GetServiceCapabilities ✨

It returns the capabilities of the device service, and the result comes back in a typed answer. slay.

You get a ONVIF::Device::Elements::GetServiceCapabilitiesResponse object back. ✨

 $response = $interface->GetServiceCapabilities( {
 },,
);

💅 GetDeviceInformation 💅

This operation grabs basic device info straight from the device. 💅

It returns a ONVIF::Device::Elements::GetDeviceInformationResponse object. 🎀

 $response = $interface->GetDeviceInformation( {
 },,
);

🌸 SetSystemDateAndTime 🌸

So the DayLightSavings flag? Set it to true to activate any DST settings of the TimeZone string. But clear the DayLightSavings flag if the DST portion of the TimeZone settings should be ignored. periodt.

It returns a ONVIF::Device::Elements::SetSystemDateAndTimeResponse object. 🌸

 $response = $interface->SetSystemDateAndTime( {
   DateTimeType => $some_value, # SetDateTimeType
   DaylightSavings =>  $some_value, # boolean
   TimeZone =>  { # ONVIF::Device::Types::TimeZone
     TZ =>  $some_value, # token
   },
   UTCDateTime =>  { # ONVIF::Device::Types::DateTime
     Time =>  { # ONVIF::Device::Types::Time
       Hour =>  $some_value, # int
       Minute =>  $some_value, # int
       Second =>  $some_value, # int
     },
     Date =>  { # ONVIF::Device::Types::Date
       Year =>  $some_value, # int
       Month =>  $some_value, # int
       Day =>  $some_value, # int
     },
   },
 },,
);

💖 GetSystemDateAndTime 💖

A device shall provide the UTCDateTime information. no cap.

It returns a ONVIF::Device::Elements::GetSystemDateAndTimeResponse object. 💖

 $response = $interface->GetSystemDateAndTime( {
 },,
);

✨ SetSystemFactoryDefault ✨

This operation reloads the parameters on the device back to their factory default values. bye bye custom settings. 😭

It returns a ONVIF::Device::Elements::SetSystemFactoryDefaultResponse object. ✨

 $response = $interface->SetSystemFactoryDefault( {
   FactoryDefault => $some_value, # FactoryDefaultType
 },,
);

🔥 UpgradeSystemFirmware 🔥

This operation upgrades a device firmware version. After a successful upgrade, the response message is sent before the device reboots. The device should support firmware upgrade through the UpgradeSystemFirmware command. But the exact format of the firmware data? That's outside the scope of this standard, so don't ask. 💅

It returns a ONVIF::Device::Elements::UpgradeSystemFirmwareResponse object. 🔥

 $response = $interface->UpgradeSystemFirmware( {
   Firmware =>  { # ONVIF::Device::Types::AttachmentData
     Include =>  { # ONVIF::Device::Types::Include
     },
   },
 },,
);

💀 SystemReboot 💀

This operation reboots the device. simple as that. 💀

It returns a ONVIF::Device::Elements::SystemRebootResponse object. 🦋

 $response = $interface->SystemReboot( {
 },,
);

💖 RestoreSystem 💖

This operation restores the system backup configuration file(s) that you previously retrieved from a device. The device should support restore of backup configuration file(s) through the RestoreSystem command. The exact format of the backup configuration file(s) is outside the scope of this standard. And if the command is supported, it shall accept backup files returned by the GetSystemBackup command. periodt.

It returns a ONVIF::Device::Elements::RestoreSystemResponse object. 💖

 $response = $interface->RestoreSystem( {
   BackupFiles =>  { # ONVIF::Device::Types::BackupFile
     Name =>  $some_value, # string
     Data =>  { # ONVIF::Device::Types::AttachmentData
       Include =>  { # ONVIF::Device::Types::Include
       },
     },
   },
 },,
);

✨ GetSystemBackup ✨

This operation retrieves system backup configuration file(s) from a device. The device should support return of backup configuration file(s) through the GetSystemBackup command. The backup is returned with reference to a name and mime-type together with binary data. The exact format of the backup configuration files is outside the scope of this standard. no cap.

It returns a ONVIF::Device::Elements::GetSystemBackupResponse object. ✨

 $response = $interface->GetSystemBackup( {
 },,
);

💅 GetSystemLog 💅

This operation gets a system log from the device. The exact format of the system logs is outside the scope of this standard. so don't come for me. 💅

It returns a ONVIF::Device::Elements::GetSystemLogResponse object. 🎀

 $response = $interface->GetSystemLog( {
   LogType => $some_value, # SystemLogType
 },,
);

🩺 GetSystemSupportInformation 🩺

This operation gets arbitrary device diagnostics information from the device. it's giving diagnostic realness. 🩺

It returns a ONVIF::Device::Elements::GetSystemSupportInformationResponse object. 🌈

 $response = $interface->GetSystemSupportInformation( {
 },,
);

💅 GetScopes 💅

Configurable Fixed scope parameters are permanent device characteristics and cannot be removed through the device management interface. The scope type is indicated in the scope list returned in the get scope parameters response. A device shall support retrieval of discovery scope parameters through the GetScopes command. And since some scope parameters are mandatory, the device shall return a non-empty scope list in the response. periodt. 💅

...and it hands you back a ONVIF::Device::Elements::GetScopesResponse object 💖 that's the whole vibe, no args, no drama.

$response = $interface->GetScopes( {
 },,
);

SetScopes

okay bestie, this one is the overwrite button 🫣 It sets the scope parameters of a device, and those scope parameters are what device discovery uses to match a probe message. Big warning: this operation replaces all existing configurable scope parameters (not the fixed ones, those stay). So if you don't wanna nuke what's already there, use the scope add command instead — AddScopes, we're getting to her 💅. Also, a device shall support configuration of discovery scope parameters through the SetScopes command.

You get a ONVIF::Device::Elements::SetScopesResponse object back ✨

$response = $interface->SetScopes( {
   Scopes =>  $some_value, # anyURI
 },,
);

AddScopes

the gentle, additive queen 🌸 She adds new configurable scope parameters to a device. Same deal as before: those scope parameters are used in device discovery to match a probe message. And the device shall support addition of discovery scope parameters through the AddScopes command.

Returns a ONVIF::Device::Elements::AddScopesResponse object 🎀

$response = $interface->AddScopes( {
   ScopeItem =>  $some_value, # anyURI
 },,
);

RemoveScopes

the opposite of AddScopes, obviously 😌 This operation deletes scope-configurable scope parameters from a device. Scope parameters are used in device discovery to match a probe message, see Section 7. The device shall support deletion of discovery scope parameters through the RemoveScopes command. (original page literally just says "Table" there and then moves on, iconic of her honestly 💀)

Returns a ONVIF::Device::Elements::RemoveScopesResponse object

$response = $interface->RemoveScopes( {
   ScopeItem =>  $some_value, # anyURI
 },,
);

GetDiscoveryMode

gets the discovery mode of a device 🕵️‍♀️ See Section 7.2 for the definition of the different device discovery modes. The device shall support retrieval of the discovery mode setting through the GetDiscoveryMode command.

Returns a ONVIF::Device::Elements::GetDiscoveryModeResponse object ⭐

$response = $interface->GetDiscoveryMode( {
 },,
);

SetDiscoveryMode

sets the discovery mode operation of a device 🔧 See Section 7.2 for the definition of the different device discovery modes. The device shall support configuration of the discovery mode setting through the SetDiscoveryMode command.

Returns a ONVIF::Device::Elements::SetDiscoveryModeResponse object

$response = $interface->SetDiscoveryMode( {
   DiscoveryMode => $some_value, # DiscoveryMode
 },,
);

GetRemoteDiscoveryMode

gets the remote discovery mode of a device 🌐 See Section 7.4 for the definition of remote discovery extensions. A device that supports remote discovery shall support retrieval of the remote discovery mode setting through the GetRemoteDiscoveryMode command.

Returns a ONVIF::Device::Elements::GetRemoteDiscoveryModeResponse object

$response = $interface->GetRemoteDiscoveryMode( {
 },,
);

SetRemoteDiscoveryMode

sets the remote discovery mode of operation of a device 🛰️ See Section 7.4 for the definition of remote discovery remote extensions. A device that supports remote discovery shall support configuration of the discovery mode setting through the SetRemoteDiscoveryMode command.

Returns a ONVIF::Device::Elements::SetRemoteDiscoveryModeResponse object

$response = $interface->SetRemoteDiscoveryMode( {
   RemoteDiscoveryMode => $some_value, # DiscoveryMode
 },,
);

GetDPAddresses

gets the remote DP address (or addresses, plural, she contains multitudes 💫) from a device. If the device supports remote discovery, as specified in Section 7.4, the device shall support retrieval of the remote DP address(es) through the GetDPAddresses command.

Returns a ONVIF::Device::Elements::GetDPAddressesResponse object

$response = $interface->GetDPAddresses( {
 },,
);

GetEndpointReference

A client can ask for the device service endpoint reference address property 🧚 which can be used to derive the password equivalent for remote user operation. The device shall support the GetEndpointReference command returning the address property of the device service endpoint reference.

Returns a ONVIF::Device::Elements::GetEndpointReferenceResponse object

$response = $interface->GetEndpointReference( {
 },,
);

GetRemoteUser

The algorithm to use for deriving the password is described in section 5.12.2.1 of the core specification. 📖

Returns a ONVIF::Device::Elements::GetRemoteUserResponse object

$response = $interface->GetRemoteUser( {
 },,
);

SetRemoteUser

To remove the remote user, SetRemoteUser should be called without the RemoteUser parameter 🫶

Returns a ONVIF::Device::Elements::SetRemoteUserResponse object

$response = $interface->SetRemoteUser( {
   RemoteUser =>  { # ONVIF::Device::Types::RemoteUser
     Username =>  $some_value, # string
     Password =>  $some_value, # string
     UseDerivedPassword =>  $some_value, # boolean
   },
 },,
);

GetUsers

lists the registered users and corresponding credentials on a device 📋 The device shall support retrieval of registered device users and their credentials for the user token through the GetUsers command.

Returns a ONVIF::Device::Elements::GetUsersResponse object

$response = $interface->GetUsers( {
 },,
);

CreateUsers

ONVIF compliant devices are recommended to support password length of at least 28 bytes 😭 because clients may follow the password derivation mechanism which results in a 'password equivalent' of length 28 bytes, as described in section 3.1.2 of the ONVIF security white paper. So yeah. 28. don't skimp.

Returns a ONVIF::Device::Elements::CreateUsersResponse object

$response = $interface->CreateUsers( {
   User =>  { # ONVIF::Device::Types::User
     Username =>  $some_value, # string
     Password =>  $some_value, # string
     UserLevel => $some_value, # UserLevel
     Extension =>  { # ONVIF::Device::Types::UserExtension
     },
   },
 },,
);

DeleteUsers

deletes users on a device 🗑️ The device shall support deletion of device users and their credentials through the DeleteUsers command. Heads up: a device may have one or more fixed users that cannot be deleted, to ensure access to the unit — so like, you can't lock yourself out, slay. And it's all-or-nothing bestie: either all users are deleted successfully, or a fault message shall be returned and no users be deleted 🔥

Returns a ONVIF::Device::Elements::DeleteUsersResponse object

$response = $interface->DeleteUsers( {
   Username =>  $some_value, # string
 },,
);

SetUser

updates the settings for one or several users on a device, for authentication purposes 🔐 The device shall support update of device users and their credentials through the SetUser command. Again with the all-or-nothing energy: either all change requests are processed successfully, or a fault message shall be returned and no change requests be processed 💅

Returns a ONVIF::Device::Elements::SetUserResponse object

$response = $interface->SetUser( {
   User =>  { # ONVIF::Device::Types::User
     Username =>  $some_value, # string
     Password =>  $some_value, # string
     UserLevel => $some_value, # UserLevel
     Extension =>  { # ONVIF::Device::Types::UserExtension
     },
   },
 },,
);

GetWsdlUrl

It's possible for an endpoint to request a URL that can be used to retrieve the complete schema and WSDL definitions of a device 📜 The command gives you back a URL entry point where all the necessary product specific WSDL and schema definitions can be retrieved. The device shall provide a URL for WSDL and schema download through the GetWsdlUrl command.

Returns a ONVIF::Device::Elements::GetWsdlUrlResponse object ✨

$response = $interface->GetWsdlUrl( {
 },,
);

GetCapabilities

Any endpoint can ask for the capabilities of a device using the capability exchange request response operation 👑 The device shall indicate all its ONVIF compliant capabilities through the GetCapabilities command. The capability list includes references to the addresses (XAddr) of the service implementing the interface operations in the category. Apart from the addresses, the capabilities only reflect optional functions — so, vibes only, bestie 💫

Returns a ONVIF::Device::Elements::GetCapabilitiesResponse object

$response = $interface->GetCapabilities( {
   Category => $some_value, # CapabilityCategory
 },,
);

SetDPAddresses

sets the remote DP address or addresses on a device 🛰️ If the device supports remote discovery, as specified in Section 7.4, the device shall support configuration of the remote DP address(es) through the SetDPAddresses command.

Returns a ONVIF::Device::Elements::SetDPAddressesResponse object

$response = $interface->SetDPAddresses( {
   DPAddress =>  { # ONVIF::Device::Types::NetworkHost
     Type => $some_value, # NetworkHostType
     IPv4Address => $some_value, # IPv4Address
     IPv6Address => $some_value, # IPv6Address
     DNSname => $some_value, # DNSName
     Extension =>  { # ONVIF::Device::Types::NetworkHostExtension
     },
   },
 },,
);

GetHostname

used by an endpoint to get the hostname from a device 🏠 The device shall return its hostname configurations through the GetHostname command.

Returns a ONVIF::Device::Elements::GetHostnameResponse object

$response = $interface->GetHostname( {
 },,
);

SetHostname

A device shall accept a string formatted according to RFC 1123 section 2.1 or alternatively to RFC 952 📚 any other string shall be considered as an invalid string. so like, format it correctly or don't come at her 😤

Returns a ONVIF::Device::Elements::SetHostnameResponse object

$response = $interface->SetHostname( {
   Name =>  $some_value, # token
 },,
);

SetHostnameFromDHCP

This one controls whether the hostname is set manually or retrieved via DHCP 🎛️ that's it, that's the whole plot.

Returns a ONVIF::Device::Elements::SetHostnameFromDHCPResponse object

$response = $interface->SetHostnameFromDHCP( {
   FromDHCP =>  $some_value, # boolean
 },,
);

GetDNS

gets the DNS settings from a device 🌐 The device shall return its DNS configurations through the GetDNS command.

Returns a ONVIF::Device::Elements::GetDNSResponse object

$response = $interface->GetDNS( {
 },,
);

SetDNS

sets the DNS settings on a device 🔧 It shall be possible to set the device DNS configurations through the SetDNS command.

Returns a ONVIF::Device::Elements::SetDNSResponse object

(okay bestie, picking up right where we left off on SetDNS — here's the shape of the whole thing you hand over 💖)

$response = $interface->SetDNS( {
   FromDHCP =>  $some_value, # boolean
   SearchDomain =>  $some_value, # token
   DNSManual =>  { # ONVIF::Device::Types::IPAddress
     Type => $some_value, # IPType
     IPv4Address => $some_value, # IPv4Address
     IPv6Address => $some_value, # IPv6Address
   },
 },,
);

✨ GetNTP ✨

Okay so this one pulls the NTP settings off the device. If the device actually supports NTP (some don't, tragic), it shall let you grab the NTP server settings via the GetNTP command.

Hands you back a ONVIF::Device::Elements::GetNTPResponse object. 🫶

$response = $interface->GetNTP( {
 },,
);

🌸 SetNTP 🌸

Heads up bestie, this one's got a plot twist: changes to the NTP server list will not affect the clock mode DateTimeType. So if you want NTP to actually do something, you gotta go call SetSystemDateAndTime to activate NTP operation. No cap.

Hands you back a ONVIF::Device::Elements::SetNTPResponse object.

$response = $interface->SetNTP( {
   FromDHCP =>  $some_value, # boolean
   NTPManual =>  { # ONVIF::Device::Types::NetworkHost
     Type => $some_value, # NetworkHostType
     IPv4Address => $some_value, # IPv4Address
     IPv6Address => $some_value, # IPv6Address
     DNSname => $some_value, # DNSName
     Extension =>  { # ONVIF::Device::Types::NetworkHostExtension
     },
   },
 },,
);

🦋 GetDynamicDNS 🦋

Grabs the dynamic DNS settings from the device. If the device supports dynamic DNS as specified in [RFC 2136] and [RFC 4702], it shall be possible to get the type, name and TTL through the GetDynamicDNS command. (iykyk those RFCs 💅)

Hands you back a ONVIF::Device::Elements::GetDynamicDNSResponse object.

$response = $interface->GetDynamicDNS( {
 },,
);

💜 SetDynamicDNS 💜

Same vibe, but setting instead of getting. This operation sets the dynamic DNS settings on a device. If the device supports dynamic DNS as specified in [RFC 2136] and [RFC 4702], it shall be possible to set the type, name and TTL through the SetDynamicDNS command. Slay.

Hands you back a ONVIF::Device::Elements::SetDynamicDNSResponse object.

$response = $interface->SetDynamicDNS( {
   Type => $some_value, # DynamicDNSType
   Name => $some_value, # DNSName
   TTL =>  $some_value, # duration
 },,
);

🌈 GetNetworkInterfaces 🌈

This one gets the network interface configuration from a device. The device shall support return of network interface configuration settings as defined by the NetworkInterface type through the GetNetworkInterfaces command. Periodt.

Hands you back a ONVIF::Device::Elements::GetNetworkInterfacesResponse object.

$response = $interface->GetNetworkInterfaces( {
 },,
);

🔥 SetNetworkInterfaces 🔥

Interop note bestie, listen up: for interoperability with a client that's unaware of the IEEE 802.11 extension, a device shall retain its IEEE 802.11 configuration if the IEEE 802.11 configuration element isn't present in the request. So don't come for it.

Hands you back a ONVIF::Device::Elements::SetNetworkInterfacesResponse object.

$response = $interface->SetNetworkInterfaces( {
   InterfaceToken => $some_value, # ReferenceToken
   NetworkInterface =>  { # ONVIF::Device::Types::NetworkInterfaceSetConfiguration
     Enabled =>  $some_value, # boolean
     Link =>  { # ONVIF::Device::Types::NetworkInterfaceConnectionSetting
       AutoNegotiation =>  $some_value, # boolean
       Speed =>  $some_value, # int
       Duplex => $some_value, # Duplex
     },
     MTU =>  $some_value, # int
     IPv4 =>  { # ONVIF::Device::Types::IPv4NetworkInterfaceSetConfiguration
       Enabled =>  $some_value, # boolean
       Manual =>  { # ONVIF::Device::Types::PrefixedIPv4Address
         Address => $some_value, # IPv4Address
         PrefixLength =>  $some_value, # int
       },
       DHCP =>  $some_value, # boolean
     },
     IPv6 =>  { # ONVIF::Device::Types::IPv6NetworkInterfaceSetConfiguration
       Enabled =>  $some_value, # boolean
       AcceptRouterAdvert =>  $some_value, # boolean
       Manual =>  { # ONVIF::Device::Types::PrefixedIPv6Address
         Address => $some_value, # IPv6Address
         PrefixLength =>  $some_value, # int
       },
       DHCP => $some_value, # IPv6DHCPConfiguration
     },
     Extension =>  { # ONVIF::Device::Types::NetworkInterfaceSetConfigurationExtension
       Dot3 =>  { # ONVIF::Device::Types::Dot3Configuration
       },
       Dot11 =>  { # ONVIF::Device::Types::Dot11Configuration
         SSID => $some_value, # Dot11SSIDType
         Mode => $some_value, # Dot11StationMode
         Alias => $some_value, # Name
         Priority => $some_value, # NetworkInterfaceConfigPriority
         Security =>  { # ONVIF::Device::Types::Dot11SecurityConfiguration
           Mode => $some_value, # Dot11SecurityMode
           Algorithm => $some_value, # Dot11Cipher
           PSK =>  { # ONVIF::Device::Types::Dot11PSKSet
             Key => $some_value, # Dot11PSK
             Passphrase => $some_value, # Dot11PSKPassphrase
             Extension =>  { # ONVIF::Device::Types::Dot11PSKSetExtension
             },
           },
           Dot1X => $some_value, # ReferenceToken
           Extension =>  { # ONVIF::Device::Types::Dot11SecurityConfigurationExtension
           },
         },
       },
       Extension =>  { # ONVIF::Device::Types::NetworkInterfaceSetConfigurationExtension2
       },
     },
   },
 },,
);

🎀 GetNetworkProtocols 🎀

Gets the defined network protocols off a device. The device shall support the GetNetworkProtocols command returning configured network protocols. Iconic behaviour honestly.

Hands you back a ONVIF::Device::Elements::GetNetworkProtocolsResponse object.

$response = $interface->GetNetworkProtocols( {
 },,
);

⭐ SetNetworkProtocols ⭐

Configures those defined network protocols on a device. The device shall support configuration of defined network protocols through the SetNetworkProtocols command. Ate.

Hands you back a ONVIF::Device::Elements::SetNetworkProtocolsResponse object.

$response = $interface->SetNetworkProtocols( {
   NetworkProtocols =>  { # ONVIF::Device::Types::NetworkProtocol
     Name => $some_value, # NetworkProtocolType
     Enabled =>  $some_value, # boolean
     Port =>  $some_value, # int
     Extension =>  { # ONVIF::Device::Types::NetworkProtocolExtension
     },
   },
 },,
);

💫 GetNetworkDefaultGateway 💫

Gets the default gateway settings from a device. The device shall support the GetNetworkDefaultGateway command returning configured default gateway address(es). Yes, addresses — plural, we're fancy.

Hands you back a ONVIF::Device::Elements::GetNetworkDefaultGatewayResponse object.

$response = $interface->GetNetworkDefaultGateway( {
 },,
);

🧚 SetNetworkDefaultGateway 🧚

Sets the default gateway settings on a device. The device shall support configuration of default gateway through the SetNetworkDefaultGateway command. Main character energy.

Hands you back a ONVIF::Device::Elements::SetNetworkDefaultGatewayResponse object.

$response = $interface->SetNetworkDefaultGateway( {
   IPv4Address => $some_value, # IPv4Address
   IPv6Address => $some_value, # IPv6Address
 },,
);

🍓 GetZeroConfiguration 🍓

Okay so lowkey important: devices supporting zero configuration on more than one interface shall use the extension to list the additional interface settings. Don't skip the extension bestie, or you're only seeing part of the picture. 🙈

Hands you back a ONVIF::Device::Elements::GetZeroConfigurationResponse object.

$response = $interface->GetZeroConfiguration( {
 },,
);

💖 SetZeroConfiguration 💖

This operation sets the zero-configuration. Use GetCapalities to get if zero-zero-configuration is supported or not. (yes that's exactly how it's spelled, I don't make the rules 💅)

Hands you back a ONVIF::Device::Elements::SetZeroConfigurationResponse object.

$response = $interface->SetZeroConfiguration( {
   InterfaceToken => $some_value, # ReferenceToken
   Enabled =>  $some_value, # boolean
 },,
);

🌸 GetIPAddressFilter 🌸

Gets the IP address filter settings from a device. If the device supports device access control based on IP filtering rules (denied or accepted ranges of IP addresses), the device shall support the GetIPAddressFilter command.

Hands you back a ONVIF::Device::Elements::GetIPAddressFilterResponse object.

$response = $interface->GetIPAddressFilter( {
 },,
);

👑 SetIPAddressFilter 👑

Sets the IP address filter settings on a device. If the device supports device access control based on IP filtering rules (denied or accepted ranges of IP addresses), the device shall support configuration of IP filtering rules through the SetIPAddressFilter command.

Hands you back a ONVIF::Device::Elements::SetIPAddressFilterResponse object.

$response = $interface->SetIPAddressFilter( {
   IPAddressFilter =>  { # ONVIF::Device::Types::IPAddressFilter
     Type => $some_value, # IPAddressFilterType
     IPv4Address =>  { # ONVIF::Device::Types::PrefixedIPv4Address
       Address => $some_value, # IPv4Address
       PrefixLength =>  $some_value, # int
     },
     IPv6Address =>  { # ONVIF::Device::Types::PrefixedIPv6Address
       Address => $some_value, # IPv6Address
       PrefixLength =>  $some_value, # int
     },
     Extension =>  { # ONVIF::Device::Types::IPAddressFilterExtension
     },
   },
 },,
);

🔥 AddIPAddressFilter 🔥

This one adds an IP filter address to a device. If the device supports device access control based on IP filtering rules (denied or accepted ranges of IP addresses), the device shall support adding of IP filtering addresses through the AddIPAddressFilter command.

Hands you back a ONVIF::Device::Elements::AddIPAddressFilterResponse object.

$response = $interface->AddIPAddressFilter( {
   IPAddressFilter =>  { # ONVIF::Device::Types::IPAddressFilter
     Type => $some_value, # IPAddressFilterType
     IPv4Address =>  { # ONVIF::Device::Types::PrefixedIPv4Address
       Address => $some_value, # IPv4Address
       PrefixLength =>  $some_value, # int
     },
     IPv6Address =>  { # ONVIF::Device::Types::PrefixedIPv6Address
       Address => $some_value, # IPv6Address
       PrefixLength =>  $some_value, # int
     },
     Extension =>  { # ONVIF::Device::Types::IPAddressFilterExtension
     },
   },
 },,
);

🦋 RemoveIPAddressFilter 🦋

And this one deletes an IP filter address from a device. If the device supports device access control based on IP filtering rules (denied or accepted ranges of IP addresses), the device shall support deletion of IP filtering addresses through the RemoveIPAddressFilter command. Bye bye filter, it's giving closure ✨

Hands you back a ONVIF::Device::Elements::RemoveIPAddressFilterResponse object.

        $response = $interface->RemoveIPAddressFilter( {
           IPAddressFilter =>  { # ONVIF::Device::Types::IPAddressFilter
             Type => $some_value, # IPAddressFilterType
             IPv4Address =>  { # ONVIF::Device::Types::PrefixedIPv4Address
               Address => $some_value, # IPv4Address
               PrefixLength =>  $some_value, # int
             },
             IPv6Address =>  { # ONVIF::Device::Types::PrefixedIPv6Address
               Address => $some_value, # IPv6Address
               PrefixLength =>  $some_value, # int
             },
             Extension =>  { # ONVIF::Device::Types::IPAddressFilterExtension
             },
           },
         },,
        );

GetAccessPolicy 🔐

okay so bestie, listen: letting literally anyone waltz into different services and lil sub-sets of services? not the vibe. Access should be controlled, periodt. The WS-Security framework is what gives you the prerequisite for end-point authentication, and then you make your authorization decisions using an access security policy. Now — this standard does not mandate any particular policy description format or security policy. That part is up to the device manufacturer or system provider to pick their policy and their policy description format of choice. But like, an access policy (in whatever arbitrary format, she's flexible 💅) can be requested using this command. And if the device supports access policy settings based on WS-Security authentication, then the device shall support this command.

Returns a ONVIF::Device::Elements::GetAccessPolicyResponse object.

 $response = $interface->GetAccessPolicy( {
 },,
);

SetAccessPolicy ✨

This one sets the device access security policy (for more deets on the access security policy, go look at the Get command, she spilled already 💖). And again: if the device supports access policy settings based on WS-Security authentication, then the device shall support this command. no cap.

Returns a ONVIF::Device::Elements::SetAccessPolicyResponse object.

 $response = $interface->SetAccessPolicy( {
   PolicyFile =>  { # ONVIF::Device::Types::BinaryData
     Data =>  $some_value, # base64Binary
   },
 },,
);

CreateCertificate 🎀

Okay so if a device supports onboard key pair generation, then the device that supports TLS shall support this certificate creation command. And also — if a device supports onboard key pair generation, the device that supports IEEE 802.1X shall support this command for the purpose of key pair generation. Certificates and key pairs are identified using certificate IDs, and those IDs are either chosen by the certificate generation requester or by the device (in the case that no ID value is given, she picks for you, generous queen 👑).

Returns a ONVIF::Device::Elements::CreateCertificateResponse object.

 $response = $interface->CreateCertificate( {
   CertificateID =>  $some_value, # token
   Subject =>  $some_value, # string
   ValidNotBefore =>  $some_value, # dateTime
   ValidNotAfter =>  $some_value, # dateTime
 },,
);

GetCertificates 🌸

This operation gets all device server certificates (including self-signed ones, yes even those) for the purpose of TLS authentication, plus all device client certificates for the purpose of IEEE 802.1X authentication. Lowkey important: this command lists only the TLS server certificates and IEEE 802.1X client certificates for the device — neither trusted CA certificates nor trusted root certificates, bestie, don't get it twisted 🙈. The certificates come back as binary data. A device that supports TLS shall support this command, and the certificates shall be encoded using ASN.1 [X.681], [X.682], [X.683] DER [X.690] encoding rules.

Returns a ONVIF::Device::Elements::GetCertificatesResponse object.

 $response = $interface->GetCertificates( {
 },,
);

GetCertificatesStatus 🦋

This operation is specific to TLS functionality. It gets the status (enabled/disabled) of the device TLS server certificates. A device that supports TLS shall support this command. simple as that 💅

Returns a ONVIF::Device::Elements::GetCertificatesStatusResponse object.

 $response = $interface->GetCertificatesStatus( {
 },,
);

SetCertificatesStatus ⭐

Also specific to TLS functionality. This one sets the status (enable/disable) of the device TLS server certificates. A device that supports TLS shall support this command. And heads up: typically only one device server certificate is allowed to be enabled at a time. one at a time, she's monogamous 🫶

Returns a ONVIF::Device::Elements::SetCertificatesStatusResponse object.

 $response = $interface->SetCertificatesStatus( {
   CertificateStatus =>  { # ONVIF::Device::Types::CertificateStatus
     CertificateID =>  $some_value, # token
     Status =>  $some_value, # boolean
   },
 },,
);

DeleteCertificates 💀

This operation deletes a certificate, or multiple certificates, she's flexible. The device MAY also delete a private/public key pair which is coupled with the certificate to be deleted. The device that supports either TLS or IEEE 802.1X shall support the deletion of a certificate or multiple certificates through this command. And here's the all-or-nothing rule: either all certificates are deleted successfully, or a fault message shall be returned without deleting any certificate. no partial mess, periodt.

Returns a ONVIF::Device::Elements::DeleteCertificatesResponse object.

 $response = $interface->DeleteCertificates( {
   CertificateID =>  $some_value, # token
 },,
);

GetPkcs10Request 🔥

A device that supports onboard key pair generation that supports either TLS or IEEE 802.1X using client certificate shall support this command.

Returns a ONVIF::Device::Elements::GetPkcs10RequestResponse object.

 $response = $interface->GetPkcs10Request( {
   CertificateID =>  $some_value, # token
   Subject =>  $some_value, # string
   Attributes =>  { # ONVIF::Device::Types::BinaryData
     Data =>  $some_value, # base64Binary
   },
 },,
);

LoadCertificates 🍓

This command is applicable to any device type, although the parameter name is called NVTCertificate for historical reasons. like, it's giving legacy naming, we don't ask questions 🎀

Returns a ONVIF::Device::Elements::LoadCertificatesResponse object.

 $response = $interface->LoadCertificates( {
   NVTCertificate =>  { # ONVIF::Device::Types::Certificate
     CertificateID =>  $some_value, # token
     Certificate =>  { # ONVIF::Device::Types::BinaryData
       Data =>  $some_value, # base64Binary
     },
   },
 },,
);

GetClientCertificateMode 🌈

This operation is specific to TLS functionality. It gets the status (enabled/disabled) of the device TLS client authentication. A device that supports TLS shall support this command.

Returns a ONVIF::Device::Elements::GetClientCertificateModeResponse object.

 $response = $interface->GetClientCertificateMode( {
 },,
);

SetClientCertificateMode 💜

Also specific to TLS functionality. This one sets the status (enabled/disabled) of the device TLS client authentication. A device that supports TLS shall support this command.

Returns a ONVIF::Device::Elements::SetClientCertificateModeResponse object.

 $response = $interface->SetClientCertificateMode( {
   Enabled =>  $some_value, # boolean
 },,
);

GetRelayOutputs 😭

⚠️ bestie this method has been deprecated with version 2.0. Refer to the DeviceIO service. it's giving retired, we still love her tho 💅

Returns a ONVIF::Device::Elements::GetRelayOutputsResponse object.

 $response = $interface->GetRelayOutputs( {
 },,
);

SetRelayOutputSettings 🙈

⚠️ also deprecated with version 2.0. Refer to the DeviceIO service.

Returns a ONVIF::Device::Elements::SetRelayOutputSettingsResponse object.

 $response = $interface->SetRelayOutputSettings( {
   RelayOutputToken => $some_value, # ReferenceToken
   Properties =>  { # ONVIF::Device::Types::RelayOutputSettings
     Mode => $some_value, # RelayMode
     DelayTime =>  $some_value, # duration
     IdleState => $some_value, # RelayIdleState
   },
 },,
);

SetRelayOutputState 🧚

⚠️ yeah you guessed it, deprecated with version 2.0. Refer to the DeviceIO service.

Returns a ONVIF::Device::Elements::SetRelayOutputStateResponse object.

 $response = $interface->SetRelayOutputState( {
   RelayOutputToken => $some_value, # ReferenceToken
   LogicalState => $some_value, # RelayLogicalState
 },,
);

SendAuxiliaryCommand 👑

tt:IRLamp|Auto — Request to configure an IR illuminator attached to the unit so that it automatically turns ON and OFF. A device that indicates auxiliary service capability shall support this command.

Returns a ONVIF::Device::Elements::SendAuxiliaryCommandResponse object.

 $response = $interface->SendAuxiliaryCommand( {
   AuxiliaryCommand => $some_value, # AuxiliaryData
 },,
);

GetCACertificates 💖

CA certificates get loaded into a device and used for the sake of the following two cases. The one is for the purpose of TLS client authentication in TLS server function. The other one is for the purpose of Authentication Server authentication in IEEE 802.1X function. This operation gets all CA certificates loaded into a device. A device that supports either TLS client authentication or IEEE 802.1X shall support this command, and the returned certificates shall be encoded using ASN.1 [X.681], [X.682], [X.683] DER [X.690] encoding rules.

Returns a ONVIF::Device::Elements::GetCACertificatesResponse object.

 $response = $interface->GetCACertificates( {
 },,
);

LoadCertificateWithPrivateKey 🔐

A device that does not support onboard key pair generation and supports either TLS or IEEE 802.1X using client certificate shall support this command. A device that supports onboard key pair generation MAY support this command. And the security policy of a device that supports this operation should make sure that the private key is sufficiently protected. protect her at all costs 🫶

Returns a ONVIF::Device::Elements::LoadCertificateWithPrivateKeyResponse object.

 $response = $interface->LoadCertificateWithPrivateKey( {
   CertificateWithPrivateKey =>  { # ONVIF::Device::Types::CertificateWithPrivateKey
     CertificateID =>  $some_value, # token
     Certificate =>  { # ONVIF::Device::Types::BinaryData
       Data =>  $some_value, # base64Binary
     },
     PrivateKey =>  { # ONVIF::Device::Types::BinaryData
       Data =>  $some_value, # base64Binary
     },
   },
 },,
);

GetCertificateInformation 🌟

A device that supports either TLS or IEEE 802.1X should support this command.

Returns a ONVIF::Device::Elements::GetCertificateInformationResponse object.

 $response = $interface->GetCertificateInformation( {
   CertificateID =>  $some_value, # token
 },,
);

LoadCACertificates 🎀

okay so a device that supports either TLS or IEEE 802.1X shall support this command, no exceptions bestie. As for the supported certificate format — either DER format or PEM format is possible to be used, so pick your fighter. BUT a device that supports this command shall support at least DER format as a supported format type, so DER is the non-negotiable one fr fr.

The device may sort the received certificate(s) based on the public key and subject information in the certificate(s) — that part's a maybe, not a must. And here's the tea: either all CA certificates are loaded successfully, or a fault message shall be returned without loading any CA certificate. It's all-or-nothing, no half-loading, periodt. 💅

Returns a ONVIF::Device::Elements::LoadCACertificatesResponse object.

$response = $interface->LoadCACertificates( {
   CACertificate =>  { # ONVIF::Device::Types::Certificate
     CertificateID =>  $some_value, # token
     Certificate =>  { # ONVIF::Device::Types::BinaryData
       Data =>  $some_value, # base64Binary
     },
   },
 },,
);

CreateDot1XConfiguration 🎀

This operation newly creates an IEEE 802.1X configuration parameter set of the device. The device shall support this command if it supports IEEE 802.1X, iykyk. And here's the plot twist: if the device receives this request with an already-existing configuration token (Dot1XConfigurationToken) specification, the device should respond with 'ter:ReferenceToken ' error to indicate there is some configuration conflict. conflict alert bestie, do not pass go 😭

Returns a ONVIF::Device::Elements::CreateDot1XConfigurationResponse object.

$response = $interface->CreateDot1XConfiguration( {
   Dot1XConfiguration =>  { # ONVIF::Device::Types::Dot1XConfiguration
     Dot1XConfigurationToken => $some_value, # ReferenceToken
     Identity =>  $some_value, # string
     AnonymousID =>  $some_value, # string
     EAPMethod =>  $some_value, # int
     CACertificateID =>  $some_value, # token
     EAPMethodConfiguration =>  { # ONVIF::Device::Types::EAPMethodConfiguration
       TLSConfiguration =>  { # ONVIF::Device::Types::TLSConfiguration
         CertificateID =>  $some_value, # token
       },
       Password =>  $some_value, # string
       Extension =>  { # ONVIF::Device::Types::EapMethodExtension
       },
     },
     Extension =>  { # ONVIF::Device::Types::Dot1XConfigurationExtension
     },
   },
 },,
);

SetDot1XConfiguration ✨

So while CreateDot1XConfiguration is out here trying to create a new configuration parameter set, this operation modifies an existing IEEE 802.1X configuration parameter set of the device. Different job, different vibe. A device that supports IEEE 802.1X shall support this command.

Returns a ONVIF::Device::Elements::SetDot1XConfigurationResponse object.

$response = $interface->SetDot1XConfiguration( {
   Dot1XConfiguration =>  { # ONVIF::Device::Types::Dot1XConfiguration
     Dot1XConfigurationToken => $some_value, # ReferenceToken
     Identity =>  $some_value, # string
     AnonymousID =>  $some_value, # string
     EAPMethod =>  $some_value, # int
     CACertificateID =>  $some_value, # token
     EAPMethodConfiguration =>  { # ONVIF::Device::Types::EAPMethodConfiguration
       TLSConfiguration =>  { # ONVIF::Device::Types::TLSConfiguration
         CertificateID =>  $some_value, # token
       },
       Password =>  $some_value, # string
       Extension =>  { # ONVIF::Device::Types::EapMethodExtension
       },
     },
     Extension =>  { # ONVIF::Device::Types::Dot1XConfigurationExtension
     },
   },
 },,
);

GetDot1XConfiguration 🦋

A device that supports IEEE 802.1X shall support this command. And listen — regardless of whether the 802.1X method in the retrieved configuration has a password or not, the device shall not include the Password element in the response. no password leaking in this house 🙈

Returns a ONVIF::Device::Elements::GetDot1XConfigurationResponse object.

$response = $interface->GetDot1XConfiguration( {
   Dot1XConfigurationToken => $some_value, # ReferenceToken
 },,
);

GetDot1XConfigurations 🌸

Same energy as the one above: regardless of whether the 802.1X method in the retrieved configuration has a password or not, the device shall not include the Password element in the response. 🫶

Returns a ONVIF::Device::Elements::GetDot1XConfigurationsResponse object.

$response = $interface->GetDot1XConfigurations( {
 },,
);

DeleteDot1XConfiguration 💀

This operation deletes an IEEE 802.1X configuration parameter set from the device. Which configuration should be deleted is specified by the 'Dot1XConfigurationToken' in the request — so be specific bestie. A device that supports IEEE 802.1X shall support this command.

Returns a ONVIF::Device::Elements::DeleteDot1XConfigurationResponse object.

$response = $interface->DeleteDot1XConfiguration( {
   Dot1XConfigurationToken => $some_value, # ReferenceToken
 },,
);

GetDot11Capabilities 🌈

This operation returns the IEEE802.11 capabilities. The device shall support this operation. That's it, that's the whole thing, and it's iconic.

Returns a ONVIF::Device::Elements::GetDot11CapabilitiesResponse object.

$response = $interface->GetDot11Capabilities( {
 },,
);

GetDot11Status ⭐

This operation returns the status of a wireless network interface. The device shall support this command. main character operation tbh.

Returns a ONVIF::Device::Elements::GetDot11StatusResponse object.

$response = $interface->GetDot11Status( {
   InterfaceToken => $some_value, # ReferenceToken
 },,
);

ScanAvailableDot11Networks 🔥

This operation returns a lists of the wireless networks in range of the device. A device should support this operation — note the should, not a shall, we keep the receipts around here.

Returns a ONVIF::Device::Elements::ScanAvailableDot11NetworksResponse object.

$response = $interface->ScanAvailableDot11Networks( {
   InterfaceToken => $some_value, # ReferenceToken
 },,
);

GetSystemUris 🧚

If the device allows retrieval of system logs, support information or system backup data, it should make them available via HTTP GET. And if it does that, it shall support the GetSystemUris command. Conditional queen 💅

Returns a ONVIF::Device::Elements::GetSystemUrisResponse object.

$response = $interface->GetSystemUris( {
 },,
);

StartFirmwareUpgrade 🚀

The value of the Content-Type header in the HTTP POST request shall be "application/octetstream". not "application/octet-stream", not "octetstream", exactly application/octetstream — copy it character for character or it's not gonna slay. 😭

Returns a ONVIF::Device::Elements::StartFirmwareUpgradeResponse object.

$response = $interface->StartFirmwareUpgrade( {
 },,
);

StartSystemRestore 💜

Same deal, same rules: the value of the Content-Type header in the HTTP POST request shall be "application/octetstream". yes, again, exactly like that.

Returns a ONVIF::Device::Elements::StartSystemRestoreResponse object.

$response = $interface->StartSystemRestore( {
 },,
);

👑 AUTHOR 👑

Generated by SOAP::WSDL on Mon Jun 30 13:36:10 2014 ✨

and that's a wrap on the whole page bestie 🎀 thank you for reading all five parts, you're literally the strongest soldier. this was perl v5.40.1, dated 2026-02-01, from the ONVIF:...icePort(3pm) page in the User Contributed Perl Documentation — go forth and configure your devices, no cap 💖🦋🌸

📦 where this page comes from

ubuntu resolute: zoneminder 1.36.37+dfsg1-1 · GPL-2.0-or-later
ubuntu stonking: zoneminder 1.36.37+dfsg1-1 · GPL-2.0-or-later
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms