blob: c7ca15953dbdf257a8ecca8e57d7e3783cdcfedd [file] [log] [blame]
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// The <code>chrome.networkingPrivate</code> API is used for configuring
// network connections (Cellular, Ethernet, VPN, WiFi or WiMAX). This private
// API is only valid if called from a browser or app associated with the
// primary user. See the Open Network Configuration (ONC) documentation for
// descriptions of properties:
// <a href="https://code.google.com/p/chromium/codesearch#chromium/src/components/onc/docs/onc_spec.html">
// src/components/onc/docs/onc_spec.html</a>, or the
// <a href="http://www.chromium.org/chromium-os/chromiumos-design-docs/open-network-configuration">
// Open Network Configuration</a> page at chromium.org.
// <br><br>
// NOTE: Most dictionary properties and enum values use UpperCamelCase to match
// the ONC spec instead of the JavaScript lowerCamelCase convention.
// <br><br>
// "State" properties describe just the ONC properties returned by
// $(ref:networkingPrivate.getState) and $(ref:networkingPrivate.getNetworks).
// <br><br>
// "Config" properties describe just the ONC properties that can be configured
// through this API. NOTE: Not all configuration properties are exposed at this
// time, only those currently required by the Chrome Settings UI.
// TODO(stevenjb): Provide all configuration properties and types,
// crbug.com/380937.
// <br><br>
// TODO(stevenjb/pneubeck): Merge the ONC documentation with this document and
// use it as the ONC specification.
namespace networkingPrivate {
enum ActivationStateType {
Activated, Activating, NotActivated, PartiallyActivated
};
enum CaptivePortalStatus {
Unknown, Offline, Online, Portal, ProxyAuthRequired
};
enum ConnectionStateType {
Connected, Connecting, NotConnected
};
enum DeviceStateType {
// Device is available but not initialized.
Uninitialized,
// Device is initialized but not enabled.
Disabled,
// Enabled state has been requested but has not completed.
Enabling,
// Device is enabled.
Enabled,
// Device is prohibited.
Prohibited
};
enum IPConfigType {
DHCP, Static
};
enum NetworkType {
All, Cellular, Ethernet, Tether, VPN, Wireless, WiFi, WiMAX
};
enum ProxySettingsType {
Direct, Manual, PAC, WPAD
};
// Managed property types. These types all share a common structure:
// Active: For properties that are translated from the configuration
// manager (e.g. Shill), the 'active' value currently in use by the
// configuration manager.
// Effective: The effective source for the property: UserPolicy, DevicePolicy,
// UserSetting or SharedSetting.
// UserPolicy: The value provided by the user policy.
// DevicePolicy: The value provided by the device policy.
// UserSetting: The value set by the logged in user. Only provided if
// UserEditable is true (i.e. no policy affects the property or the
// policy provided value is recommened only).
// SharedSetting: The value set for all users of the device. Only provided if
// DeviceEditiable is true (i.e. no policy affects the property or the
// policy provided value is recommened only).
// UserEditable: True if a UserPolicy exists and allows the property to be
// edited (i.e. is a recommended value). Defaults to False.
// DeviceEditable: True if a DevicePolicy exists and allows the property to be
// edited (i.e. is a recommended value). Defaults to False.
dictionary ManagedBoolean {
boolean? Active;
DOMString? Effective;
boolean? UserPolicy;
boolean? DevicePolicy;
boolean? UserSetting;
boolean? SharedSetting;
boolean? UserEditable;
boolean? DeviceEditable;
};
dictionary ManagedLong {
long? Active;
DOMString? Effective;
long? UserPolicy;
long? DevicePolicy;
long? UserSetting;
long? SharedSetting;
boolean? UserEditable;
boolean? DeviceEditable;
};
dictionary ManagedDOMString {
DOMString? Active;
DOMString? Effective;
DOMString? UserPolicy;
DOMString? DevicePolicy;
DOMString? UserSetting;
DOMString? SharedSetting;
boolean? UserEditable;
boolean? DeviceEditable;
};
dictionary ManagedDOMStringList {
DOMString[]? Active;
DOMString? Effective;
DOMString[]? UserPolicy;
DOMString[]? DevicePolicy;
DOMString[]? UserSetting;
DOMString[]? SharedSetting;
boolean? UserEditable;
boolean? DeviceEditable;
};
dictionary ManagedIPConfigType {
IPConfigType? Active;
DOMString? Effective;
IPConfigType? UserPolicy;
IPConfigType? DevicePolicy;
IPConfigType? UserSetting;
IPConfigType? SharedSetting;
boolean? UserEditable;
boolean? DeviceEditable;
};
dictionary ManagedProxySettingsType {
ProxySettingsType? Active;
DOMString? Effective;
ProxySettingsType? UserPolicy;
ProxySettingsType? DevicePolicy;
ProxySettingsType? UserSetting;
ProxySettingsType? SharedSetting;
boolean? UserEditable;
boolean? DeviceEditable;
};
// Sub-dictionary types.
dictionary APNProperties {
DOMString AccessPointName;
DOMString? Authentication;
DOMString? Language;
DOMString? LocalizedName;
DOMString? Name;
DOMString? Password;
DOMString? Username;
};
dictionary ManagedAPNProperties {
ManagedDOMString AccessPointName;
ManagedDOMString? Authentication;
ManagedDOMString? Language;
ManagedDOMString? LocalizedName;
ManagedDOMString? Name;
ManagedDOMString? Password;
ManagedDOMString? Username;
};
dictionary ManagedAPNList {
APNProperties[]? Active;
DOMString? Effective;
APNProperties[]? UserPolicy;
APNProperties[]? DevicePolicy;
APNProperties[]? UserSetting;
APNProperties[]? SharedSetting;
boolean? UserEditable;
boolean? DeviceEditable;
};
dictionary CellularProviderProperties {
DOMString Name;
DOMString Code;
DOMString? Country;
};
dictionary CellularSimState {
// Whether or not a PIN should be required.
boolean requirePin;
// The current PIN (required for any change, even when the SIM is unlocked).
DOMString currentPin;
// If provided, change the PIN to |newPin|. |requirePin| must be true.
DOMString? newPin;
};
dictionary IssuerSubjectPattern {
DOMString? CommonName;
DOMString? Locality;
DOMString? Organization;
DOMString? OrganizationalUnit;
};
dictionary ManagedIssuerSubjectPattern {
ManagedDOMString? CommonName;
ManagedDOMString? Locality;
ManagedDOMString? Organization;
ManagedDOMString? OrganizationalUnit;
};
dictionary CertificatePattern {
DOMString[]? EnrollmentURI;
IssuerSubjectPattern? Issuer;
DOMString[]? IssuerCARef;
IssuerSubjectPattern? Subject;
};
dictionary ManagedCertificatePattern {
ManagedDOMStringList? EnrollmentURI;
ManagedIssuerSubjectPattern? Issuer;
ManagedDOMStringList? IssuerCARef;
ManagedIssuerSubjectPattern? Subject;
};
dictionary EAPProperties {
DOMString? AnonymousIdentity;
CertificatePattern? ClientCertPattern;
DOMString? ClientCertPKCS11Id;
DOMString? ClientCertRef;
DOMString? ClientCertType;
DOMString? Identity;
DOMString? Inner;
// The outer EAP type. Required by ONC, but may not be provided when
// translating from Shill.
DOMString? Outer;
DOMString? Password;
boolean? SaveCredentials;
DOMString[]? ServerCAPEMs;
DOMString[]? ServerCARefs;
DOMString? SubjectMatch;
DOMString? TLSVersionMax;
boolean? UseProactiveKeyCaching;
boolean? UseSystemCAs;
};
dictionary ManagedEAPProperties {
ManagedDOMString? AnonymousIdentity;
ManagedCertificatePattern? ClientCertPattern;
ManagedDOMString? ClientCertPKCS11Id;
ManagedDOMString? ClientCertRef;
ManagedDOMString? ClientCertType;
ManagedDOMString? Identity;
ManagedDOMString? Inner;
// The outer EAP type. Required by ONC, but may not be provided when
// translating from Shill.
ManagedDOMString? Outer;
ManagedDOMString? Password;
ManagedBoolean? SaveCredentials;
ManagedDOMStringList? ServerCAPEMs;
ManagedDOMStringList? ServerCARefs;
ManagedDOMString? SubjectMatch;
ManagedDOMString? TLSVersionMax;
ManagedBoolean? UseProactiveKeyCaching;
ManagedBoolean? UseSystemCAs;
};
dictionary FoundNetworkProperties {
DOMString Status;
DOMString NetworkId;
DOMString Technology;
DOMString? ShortName;
DOMString? LongName;
};
dictionary IPConfigProperties {
DOMString? Gateway;
DOMString? IPAddress;
DOMString[]? NameServers;
long? RoutingPrefix;
DOMString? Type;
DOMString? WebProxyAutoDiscoveryUrl;
};
dictionary ManagedIPConfigProperties {
ManagedDOMString? Gateway;
ManagedDOMString? IPAddress;
ManagedDOMStringList? NameServers;
ManagedLong? RoutingPrefix;
ManagedDOMString? Type;
ManagedDOMString? WebProxyAutoDiscoveryUrl;
};
dictionary XAUTHProperties {
DOMString? Password;
boolean? SaveCredentials;
DOMString? Username;
};
dictionary ManagedXAUTHProperties {
ManagedDOMString? Password;
ManagedBoolean? SaveCredentials;
ManagedDOMString? Username;
};
dictionary IPSecProperties {
DOMString AuthenticationType;
CertificatePattern? ClientCertPattern;
DOMString? ClientCertPKCS11Id;
DOMString? ClientCertRef;
DOMString? ClientCertType;
EAPProperties? EAP;
DOMString? Group;
long? IKEVersion;
DOMString? PSK;
boolean? SaveCredentials;
DOMString[]? ServerCAPEMs;
DOMString[]? ServerCARefs;
XAUTHProperties? XAUTH;
};
dictionary ManagedIPSecProperties {
ManagedDOMString AuthenticationType;
ManagedCertificatePattern? ClientCertPattern;
ManagedDOMString? ClientCertPKCS11Id;
ManagedDOMString? ClientCertRef;
ManagedDOMString? ClientCertType;
ManagedEAPProperties? EAP;
ManagedDOMString? Group;
ManagedLong? IKEVersion;
ManagedDOMString? PSK;
ManagedBoolean? SaveCredentials;
ManagedDOMStringList? ServerCAPEMs;
ManagedDOMStringList? ServerCARefs;
ManagedXAUTHProperties? XAUTH;
};
dictionary L2TPProperties {
boolean? LcpEchoDisabled;
DOMString? Password;
boolean? SaveCredentials;
DOMString? Username;
};
dictionary ManagedL2TPProperties {
ManagedBoolean? LcpEchoDisabled;
ManagedDOMString? Password;
ManagedBoolean? SaveCredentials;
ManagedDOMString? Username;
};
dictionary PaymentPortal {
DOMString Method;
DOMString? PostData;
DOMString? Url;
};
dictionary ProxyLocation {
DOMString Host;
long Port;
};
dictionary ManagedProxyLocation {
ManagedDOMString Host;
ManagedLong Port;
};
dictionary ManualProxySettings {
ProxyLocation? HTTPProxy;
ProxyLocation? SecureHTTPProxy;
ProxyLocation? FTPProxy;
ProxyLocation? SOCKS;
};
dictionary ManagedManualProxySettings {
ManagedProxyLocation? HTTPProxy;
ManagedProxyLocation? SecureHTTPProxy;
ManagedProxyLocation? FTPProxy;
ManagedProxyLocation? SOCKS;
};
dictionary ProxySettings {
ProxySettingsType Type;
ManualProxySettings? Manual;
DOMString[]? ExcludeDomains;
DOMString? PAC;
};
dictionary ManagedProxySettings {
ManagedProxySettingsType Type;
ManagedManualProxySettings? Manual;
ManagedDOMStringList? ExcludeDomains;
ManagedDOMString? PAC;
};
dictionary VerifyX509 {
DOMString? Name;
DOMString? Type;
};
dictionary ManagedVerifyX509 {
ManagedDOMString? Name;
ManagedDOMString? Type;
};
dictionary OpenVPNProperties {
DOMString? Auth;
DOMString? AuthRetry;
boolean? AuthNoCache;
DOMString? Cipher;
DOMString? ClientCertPKCS11Id;
CertificatePattern? ClientCertPattern;
DOMString? ClientCertRef;
DOMString? ClientCertType;
DOMString? CompLZO;
boolean? CompNoAdapt;
DOMString[]? ExtraHosts;
boolean? IgnoreDefaultRoute;
DOMString? KeyDirection;
DOMString? NsCertType;
DOMString? OTP;
DOMString? Password;
long? Port;
DOMString? Proto;
boolean? PushPeerInfo;
DOMString? RemoteCertEKU;
DOMString[]? RemoteCertKU;
DOMString? RemoteCertTLS;
long? RenegSec;
boolean? SaveCredentials;
DOMString[]? ServerCAPEMs;
DOMString[]? ServerCARefs;
DOMString? ServerCertRef;
long? ServerPollTimeout;
long? Shaper;
DOMString? StaticChallenge;
DOMString? TLSAuthContents;
DOMString? TLSRemote;
DOMString? TLSVersionMin;
DOMString? UserAuthenticationType;
DOMString? Username;
DOMString? Verb;
DOMString? VerifyHash;
VerifyX509? VerifyX509;
};
dictionary ManagedOpenVPNProperties {
ManagedDOMString? Auth;
ManagedDOMString? AuthRetry;
ManagedBoolean? AuthNoCache;
ManagedDOMString? Cipher;
ManagedDOMString? ClientCertPKCS11Id;
ManagedCertificatePattern? ClientCertPattern;
ManagedDOMString? ClientCertRef;
ManagedDOMString? ClientCertType;
ManagedDOMString? CompLZO;
ManagedBoolean? CompNoAdapt;
ManagedDOMStringList? ExtraHosts;
ManagedBoolean? IgnoreDefaultRoute;
ManagedDOMString? KeyDirection;
ManagedDOMString? NsCertType;
ManagedDOMString? OTP;
ManagedDOMString? Password;
ManagedLong? Port;
ManagedDOMString? Proto;
ManagedBoolean? PushPeerInfo;
ManagedDOMString? RemoteCertEKU;
ManagedDOMStringList? RemoteCertKU;
ManagedDOMString? RemoteCertTLS;
ManagedLong? RenegSec;
ManagedBoolean? SaveCredentials;
ManagedDOMStringList? ServerCAPEMs;
ManagedDOMStringList? ServerCARefs;
ManagedDOMString? ServerCertRef;
ManagedLong? ServerPollTimeout;
ManagedLong? Shaper;
ManagedDOMString? StaticChallenge;
ManagedDOMString? TLSAuthContents;
ManagedDOMString? TLSRemote;
ManagedDOMString? TLSVersionMin;
ManagedDOMString? UserAuthenticationType;
ManagedDOMString? Username;
ManagedDOMString? Verb;
ManagedDOMString? VerifyHash;
ManagedVerifyX509? VerifyX509;
};
dictionary SIMLockStatus {
DOMString LockType; // sim-pin, sim-puk, or ''
boolean LockEnabled;
long? RetriesLeft;
};
dictionary ThirdPartyVPNProperties {
DOMString ExtensionID;
DOMString? ProviderName;
};
dictionary ManagedThirdPartyVPNProperties {
ManagedDOMString ExtensionID;
DOMString? ProviderName;
};
// Network type dictionary types.
dictionary CellularProperties {
boolean? AutoConnect;
APNProperties? APN;
APNProperties[]? APNList;
DOMString? ActivationType;
ActivationStateType? ActivationState;
boolean? AllowRoaming;
DOMString? Carrier;
DOMString? ESN;
DOMString? Family;
DOMString? FirmwareRevision;
FoundNetworkProperties[]? FoundNetworks;
DOMString? HardwareRevision;
CellularProviderProperties? HomeProvider;
DOMString? ICCID;
DOMString? IMEI;
APNProperties? LastGoodAPN;
DOMString? Manufacturer;
DOMString? MDN;
DOMString? MEID;
DOMString? MIN;
DOMString? ModelID;
DOMString? NetworkTechnology;
PaymentPortal? PaymentPortal;
long? PRLVersion;
DOMString? RoamingState;
boolean? Scanning;
CellularProviderProperties? ServingOperator;
SIMLockStatus? SIMLockStatus;
boolean? SIMPresent;
long? SignalStrength;
boolean? SupportNetworkScan;
DOMString[]? SupportedCarriers;
};
dictionary ManagedCellularProperties {
ManagedBoolean? AutoConnect;
ManagedAPNProperties? APN;
ManagedAPNList? APNList;
DOMString? ActivationType;
ActivationStateType? ActivationState;
boolean? AllowRoaming;
ManagedDOMString? Carrier;
DOMString? ESN;
DOMString? Family;
DOMString? FirmwareRevision;
FoundNetworkProperties[]? FoundNetworks;
DOMString? HardwareRevision;
CellularProviderProperties? HomeProvider;
DOMString? ICCID;
DOMString? IMEI;
APNProperties? LastGoodAPN;
DOMString? Manufacturer;
DOMString? MDN;
DOMString? MEID;
DOMString? MIN;
DOMString? ModelID;
DOMString? NetworkTechnology;
PaymentPortal? PaymentPortal;
long? PRLVersion;
DOMString? RoamingState;
boolean? Scanning;
CellularProviderProperties? ServingOperator;
SIMLockStatus? SIMLockStatus;
boolean? SIMPresent;
long? SignalStrength;
boolean? SupportNetworkScan;
DOMString[]? SupportedCarriers;
};
dictionary CellularStateProperties {
ActivationStateType? ActivationState;
DOMString? NetworkTechnology;
DOMString? RoamingState;
boolean? Scanning;
boolean? SIMPresent;
long? SignalStrength;
};
dictionary EAPStateProperties {
DOMString? Outer;
};
dictionary EthernetProperties {
boolean? AutoConnect;
DOMString? Authentication;
EAPProperties? EAP;
};
dictionary ManagedEthernetProperties {
ManagedBoolean? AutoConnect;
ManagedDOMString? Authentication;
ManagedEAPProperties? EAP;
};
dictionary EthernetStateProperties {
DOMString Authentication;
};
dictionary TetherProperties {
long? BatteryPercentage;
DOMString? Carrier;
boolean HasConnectedToHost;
long? SignalStrength;
};
dictionary VPNProperties {
boolean? AutoConnect;
DOMString? Host;
IPSecProperties? IPsec;
L2TPProperties? L2TP;
OpenVPNProperties? OpenVPN;
ThirdPartyVPNProperties? ThirdPartyVPN;
// The VPN type. This cannot be an enum because of 'L2TP-IPSec'.
// This is optional for NetworkConfigProperties which is passed to
// setProperties which may be used to set only specific properties.
DOMString? Type;
};
dictionary ManagedVPNProperties {
ManagedBoolean? AutoConnect;
ManagedDOMString? Host;
ManagedIPSecProperties? IPsec;
ManagedL2TPProperties? L2TP;
ManagedOpenVPNProperties? OpenVPN;
ManagedThirdPartyVPNProperties? ThirdPartyVPN;
ManagedDOMString? Type;
};
dictionary VPNStateProperties {
DOMString Type;
IPSecProperties? IPsec;
ThirdPartyVPNProperties? ThirdPartyVPN;
};
dictionary WiFiProperties {
boolean? AllowGatewayARPPolling;
boolean? AutoConnect;
DOMString? BSSID;
EAPProperties? EAP;
long? Frequency;
long[]? FrequencyList;
boolean? FTEnabled;
DOMString? HexSSID;
boolean? HiddenSSID;
DOMString? Passphrase;
long? RoamThreshold;
DOMString? SSID;
DOMString? Security;
long? SignalStrength;
DOMString? TetheringState;
};
dictionary ManagedWiFiProperties {
ManagedBoolean? AllowGatewayARPPolling;
ManagedBoolean? AutoConnect;
DOMString? BSSID;
ManagedEAPProperties? EAP;
long? Frequency;
long[]? FrequencyList;
ManagedBoolean? FTEnabled;
ManagedDOMString? HexSSID;
ManagedBoolean? HiddenSSID;
ManagedDOMString? Passphrase;
ManagedLong? RoamThreshold;
ManagedDOMString? SSID;
ManagedDOMString Security;
long? SignalStrength;
DOMString? TetheringState;
};
dictionary WiFiStateProperties {
DOMString? BSSID;
EAPStateProperties? EAP;
long? Frequency;
DOMString? HexSSID;
DOMString Security;
long? SignalStrength;
DOMString? SSID;
DOMString? TetheringState;
};
dictionary WiMAXProperties {
boolean? AutoConnect;
EAPProperties? EAP;
long? SignalStrength;
};
dictionary ManagedWiMAXProperties {
ManagedBoolean? AutoConnect;
ManagedEAPProperties? EAP;
long? SignalStrength;
};
dictionary WiMAXStateProperties {
long? SignalStrength;
};
dictionary NetworkConfigProperties {
CellularProperties? Cellular;
EthernetProperties? Ethernet;
DOMString? GUID;
IPConfigType? IPAddressConfigType;
DOMString? Name;
IPConfigType? NameServersConfigType;
long? Priority;
ProxySettings? ProxySettings;
IPConfigProperties? StaticIPConfig;
NetworkType? Type;
VPNProperties? VPN;
WiFiProperties? WiFi;
WiMAXProperties? WiMAX;
};
dictionary NetworkProperties {
CellularProperties? Cellular;
boolean? Connectable;
ConnectionStateType? ConnectionState;
DOMString? ErrorState;
EthernetProperties? Ethernet;
DOMString GUID;
IPConfigType? IPAddressConfigType;
IPConfigProperties[]? IPConfigs;
DOMString? MacAddress;
DOMString? Name;
IPConfigType? NameServersConfigType;
long? Priority;
ProxySettings? ProxySettings;
boolean? RestrictedConnectivity;
IPConfigProperties? StaticIPConfig;
IPConfigProperties? SavedIPConfig;
// Indicates whether and how the network is configured.
// 'Source' can be Device, DevicePolicy, User, UserPolicy or None.
// 'None' conflicts with extension code generation so we must use a string
// for 'Source' instead of a SourceType enum.
DOMString? Source;
TetherProperties? Tether;
NetworkType Type;
VPNProperties? VPN;
WiFiProperties? WiFi;
WiMAXProperties? WiMAX;
};
dictionary ManagedProperties {
ManagedCellularProperties? Cellular;
boolean? Connectable;
ConnectionStateType? ConnectionState;
DOMString? ErrorState;
ManagedEthernetProperties? Ethernet;
DOMString GUID;
ManagedIPConfigType? IPAddressConfigType;
IPConfigProperties[]? IPConfigs;
DOMString? MacAddress;
ManagedDOMString? Name;
ManagedIPConfigType? NameServersConfigType;
ManagedLong? Priority;
ManagedProxySettings? ProxySettings;
boolean? RestrictedConnectivity;
ManagedIPConfigProperties? StaticIPConfig;
IPConfigProperties? SavedIPConfig;
// See $(ref:NetworkProperties.Source).
DOMString? Source;
TetherProperties? Tether;
NetworkType Type;
ManagedVPNProperties? VPN;
ManagedWiFiProperties? WiFi;
ManagedWiMAXProperties? WiMAX;
};
dictionary NetworkStateProperties {
CellularStateProperties? Cellular;
boolean? Connectable;
ConnectionStateType? ConnectionState;
EthernetStateProperties? Ethernet;
DOMString? ErrorState;
DOMString GUID;
DOMString? Name;
long? Priority;
// See $(ref:NetworkProperties.Source).
DOMString? Source;
TetherProperties? Tether;
NetworkType Type;
VPNStateProperties? VPN;
WiFiStateProperties? WiFi;
WiMAXStateProperties? WiMAX;
};
dictionary DeviceStateProperties {
// Set if the device is enabled. True if the device is currently scanning.
boolean? Scanning;
// The SIM lock status if Type = Cellular and SIMPresent = True.
SIMLockStatus? SIMLockStatus;
// Set to the SIM present state if the device type is Cellular.
boolean? SIMPresent;
// The current state of the device.
DeviceStateType State;
// The network type associated with the device (Cellular, Ethernet, WiFi, or
// WiMAX).
NetworkType Type;
// Whether or not any managed networks are available/visible.
boolean? ManagedNetworkAvailable;
};
dictionary VerificationProperties {
// A string containing a PEM-encoded (including the 'BEGIN CERTIFICATE'
// header and 'END CERTIFICATE' footer) X.509 certificate for use in
// verifying the signed data.
DOMString certificate;
// An array of PEM-encoded X.509 intermediate certificate authority
// certificates. Each PEM-encoded certificate is expected to have the
// 'BEGIN CERTIFICATE' header and 'END CERTIFICATE' footer.
DOMString[]? intermediateCertificates;
// A string containing a base64-encoded RSAPublicKey ASN.1 structure,
// representing the public key to be used by
// $(ref:verifyAndEncryptCredentials) and $(ref:verifyAndEncryptData)
// methods.
DOMString publicKey;
// A string containing a base64-encoded random binary data for use in
// verifying the signed data.
DOMString nonce;
// A string containing the identifying data string signed by the device.
DOMString signedData;
// A string containing the serial number of the device.
DOMString deviceSerial;
// A string containing the SSID of the device. Should be empty for new
// configurations.
DOMString deviceSsid;
// A string containing the BSSID of the device. Should be empty for new
// configurations.
DOMString deviceBssid;
};
dictionary NetworkFilter {
// The type of networks to return.
NetworkType networkType;
// If true, only include visible (physically connected or in-range)
// networks. Defaults to 'false'.
boolean? visible;
// If true, only include configured (saved) networks. Defaults to 'false'.
boolean? configured;
// Maximum number of networks to return. Defaults to 1000 if unspecified.
// Use 0 for no limit.
long? limit;
};
dictionary GlobalPolicy {
// If true, only policy networks may auto connect. Defaults to false.
boolean? AllowOnlyPolicyNetworksToAutoconnect;
// If true, only policy networks may be connected to and no new networks may
// be added or configured. Defaults to false.
boolean? AllowOnlyPolicyNetworksToConnect;
// If true and a managed network is available in the visible network list,
// only policy networks may be connected to and no new networks may be added
// or configured. Defaults to false.
boolean? AllowOnlyPolicyNetworksToConnectIfAvailable;
// List of blacklisted networks. Connections to blacklisted networks are
// prohibited. Networks can be whitelisted again by specifying an explicit
// network configuration. Defaults to an empty list.
DOMString[]? BlacklistedHexSSIDs;
};
dictionary Certificate {
// Unique hash for the certificate.
DOMString hash;
// Certificate issuer common name.
DOMString issuedBy;
// Certificate name or nickname.
DOMString issuedTo;
// PEM for server CA certificates.
DOMString? pem;
// PKCS#11 id for user certificates.
DOMString? PKCS11Id;
// Whether or not the certificate is hardware backed.
boolean hardwareBacked;
};
dictionary CertificateLists {
// List of avaliable server CA certificates.
Certificate[] serverCaCertificates;
// List of available user certificates.
Certificate[] userCertificates;
};
callback VoidCallback = void();
callback BooleanCallback = void(boolean result);
callback StringCallback = void(DOMString result);
// TODO(stevenjb): Use NetworkProperties for |result| once defined.
callback GetPropertiesCallback = void(NetworkProperties result);
// TODO(stevenjb): Use ManagedNetworkProperties for |result| once defined.
callback GetManagedPropertiesCallback = void(ManagedProperties result);
callback GetStatePropertiesCallback = void(NetworkStateProperties result);
callback GetNetworksCallback = void(NetworkStateProperties[] result);
callback GetDeviceStatesCallback = void(DeviceStateProperties[] result);
callback GetEnabledNetworkTypesCallback = void(NetworkType[] result);
callback CaptivePortalStatusCallback = void(CaptivePortalStatus result);
callback GetGlobalPolicyCallback = void(GlobalPolicy result);
callback GetCertificateListsCallback = void(CertificateLists result);
// These functions all report failures via $(ref:runtime.lastError).
interface Functions {
// Gets all the properties of the network with id networkGuid. Includes all
// properties of the network (read-only and read/write values).
// |networkGuid|: The GUID of the network to get properties for.
// |callback|: Called with the network properties when received.
static void getProperties(DOMString networkGuid,
GetPropertiesCallback callback);
// Gets the merged properties of the network with id networkGuid from the
// sources: User settings, shared settings, user policy, device policy and
// the currently active settings.
// |networkGuid|: The GUID of the network to get properties for.
// |callback|: Called with the managed network properties when received.
static void getManagedProperties(DOMString networkGuid,
GetManagedPropertiesCallback callback);
// Gets the cached read-only properties of the network with id networkGuid.
// This is meant to be a higher performance function than
// $(ref:getProperties), which requires a round trip to query the networking
// subsystem. The following properties are returned for all networks: GUID,
// Type, Name, WiFi.Security. Additional properties are provided for visible
// networks: ConnectionState, ErrorState, WiFi.SignalStrength,
// Cellular.NetworkTechnology, Cellular.ActivationState,
// Cellular.RoamingState.
// |networkGuid|: The GUID of the network to get properties for.
// |callback|: Called immediately with the network state properties.
static void getState(DOMString networkGuid,
GetStatePropertiesCallback callback);
// Sets the properties of the network with id |networkGuid|. This is only
// valid for configured networks (Source != None). Unconfigured visible
// networks should use createNetwork instead.
// |networkGuid|: The GUID of the network to set properties for.
// |properties|: The properties to set.
// |callback|: Called when the operation has completed.
static void setProperties(DOMString networkGuid,
NetworkConfigProperties properties,
optional VoidCallback callback);
// Creates a new network configuration from properties. If a matching
// configured network already exists, this will fail. Otherwise returns the
// guid of the new network.
// |shared|: If true, share this network configuration with other users.
// |properties|: The properties to configure the new network with.
// |callback|: Called with the GUID for the new network configuration once
// the network has been created.
static void createNetwork(boolean shared,
NetworkConfigProperties properties,
optional StringCallback callback);
// Forgets a network configuration by clearing any configured properties for
// the network with GUID 'networkGuid'. This may also include any other
// networks with matching identifiers (e.g. WiFi SSID and Security). If no
// such configuration exists, an error will be set and the operation will
// fail.
// |networkGuid|: The GUID of the network to forget.
// |callback|: Called when the operation has completed.
static void forgetNetwork(DOMString networkGuid,
optional VoidCallback callback);
// Returns a list of network objects with the same properties provided by
// $(ref:networkingPrivate.getState). A filter is provided to specify the
// type of networks returned and to limit the number of networks. Networks
// are ordered by the system based on their priority, with connected or
// connecting networks listed first.
// |filter|: Describes which networks to return.
// |callback|: Called with a dictionary of networks and their state
// properties when received.
static void getNetworks(NetworkFilter filter,
GetNetworksCallback callback);
// Deprecated. Please use $(ref:networkingPrivate.getNetworks) with
// filter.visible = true instead.
[deprecated="Use getNetworks."] static void getVisibleNetworks(
NetworkType networkType,
GetNetworksCallback callback);
// Deprecated. Please use $(ref:networkingPrivate.getDeviceStates) instead.
[deprecated="Use getDeviceStates."] static void getEnabledNetworkTypes(
GetEnabledNetworkTypesCallback callback);
// Returns a list of $(ref:networkingPrivate.DeviceStateProperties) objects.
// |callback|: Called with a list of devices and their state.
static void getDeviceStates(GetDeviceStatesCallback callback);
// Enables any devices matching the specified network type. Note, the type
// might represent multiple network types (e.g. 'Wireless').
// |networkType|: The type of network to enable.
static void enableNetworkType(NetworkType networkType);
// Disables any devices matching the specified network type. See note for
// $(ref:networkingPrivate.enableNetworkType).
// |networkType|: The type of network to disable.
static void disableNetworkType(NetworkType networkType);
// Requests that the networking subsystem scan for new networks and
// update the list returned by $(ref:getVisibleNetworks). This is only a
// request: the network subsystem can choose to ignore it. If the list
// is updated, then the $(ref:onNetworkListChanged) event will be fired.
// |networkType|: If provided, requests a scan specific to the type.
// For Cellular a mobile network scan will be requested if supported.
static void requestNetworkScan(optional NetworkType networkType);
// Starts a connection to the network with networkGuid.
// |networkGuid|: The GUID of the network to connect to.
// |callback|: Called when the connect request has been sent. Note: the
// connection may not have completed. Observe $(ref:onNetworksChanged)
// to be notified when a network state changes. If the connect request
// immediately failed (e.g. the network is unconfigured),
// $(ref:runtime.lastError) will be set with a failure reason.
static void startConnect(DOMString networkGuid,
optional VoidCallback callback);
// Starts a disconnect from the network with networkGuid.
// |networkGuid|: The GUID of the network to disconnect from.
// |callback|: Called when the disconnect request has been sent. See note
// for $(ref:startConnect).
static void startDisconnect(DOMString networkGuid,
optional VoidCallback callback);
// Starts activation of the Cellular network with networkGuid. If called
// for a network that is already activated, or for a network with a carrier
// that can not be directly activated, this will show the account details
// page for the carrier if possible.
// |networkGuid|: The GUID of the Cellular network to activate.
// |carrier|: Optional name of carrier to activate.
// |callback|: Called when the activation request has been sent. See note
// for $(ref:startConnect).
static void startActivate(DOMString networkGuid,
optional DOMString carrier,
optional VoidCallback callback);
// Verifies that the device is a trusted device.
// |properties|: Properties of the destination to use in verifying that it
// is a trusted device.
// |callback|: A callback function that indicates whether or not the device
// is a trusted device.
[nodoc, deprecated = "Use networking.castPrivate API."]
static void verifyDestination(VerificationProperties properties,
BooleanCallback callback);
// Verifies that the device is a trusted device and retrieves encrypted
// network credentials.
// |properties|: Properties of the destination to use in verifying that it
// is a trusted device.
// |networkGuid|: The GUID of the Cellular network to activate.
// |callback|: A callback function that receives base64-encoded encrypted
// credential data to send to a trusted device.
[nodoc, deprecated = "Use networking.castPrivate API."]
static void verifyAndEncryptCredentials(VerificationProperties properties,
DOMString networkGuid,
StringCallback callback);
// Verifies that the device is a trusted device and encrypts supplied
// data with device public key.
// |properties|: Properties of the destination to use in verifying that it
// is a trusted device.
// |data|: A string containing the base64-encoded data to encrypt.
// |callback|: A callback function that receives base64-encoded encrypted
// data to send to a trusted device.
[nodoc, deprecated = "Use networking.castPrivate API."]
static void verifyAndEncryptData(VerificationProperties properties,
DOMString data,
StringCallback callback);
// Enables TDLS for WiFi traffic with a specified peer if available.
// |ip_or_mac_address|: The IP or MAC address of the peer with which to
// enable a TDLS connection.
// |enabled| If true, enable TDLS, otherwise disable TDLS.
// |callback|: A callback function that receives a string with an error or
// the current TDLS status. 'Failed' indicates that the request failed
// (e.g. MAC address lookup failed). 'Timeout' indicates that the lookup
// timed out. Otherwise a valid status is returned (see
// $(ref:getWifiTDLSStatus)).
[nodoc, deprecated = "Use networking.castPrivate API."]
static void setWifiTDLSEnabledState(DOMString ip_or_mac_address,
boolean enabled,
optional StringCallback callback);
// Returns the current TDLS status for the specified peer.
// |ip_or_mac_address|: The IP or MAC address of the peer.
// |callback|: A callback function that receives a string with the current
// TDLS status which can be 'Connected', 'Disabled', 'Disconnected',
// 'Nonexistent', or 'Unknown'.
[nodoc, deprecated = "Use networking.castPrivate API."]
static void getWifiTDLSStatus(DOMString ip_or_mac_address,
StringCallback callback);
// Returns captive portal status for the network matching 'networkGuid'.
// |networkGuid|: The GUID of the network to get captive portal status for.
// |callback|: A callback function that returns the results of the query for
// network captive portal status.
static void getCaptivePortalStatus(DOMString networkGuid,
CaptivePortalStatusCallback callback);
// Unlocks a Cellular SIM card.
// * If the SIM is PIN locked, |pin| will be used to unlock the SIM and
// the |puk| argument will be ignored if provided.
// * If the SIM is PUK locked, |puk| and |pin| must be provided. If the
// operation succeeds (|puk| is valid), the PIN will be set to |pin|.
// (If |pin| is empty or invalid the operation will fail).
// |networkGuid|: The GUID of the cellular network to unlock.
// If empty, the default cellular device will be used.
// |pin|: The current SIM PIN, or the new PIN if PUK is provided.
// |puk|: The operator provided PUK for unblocking a blocked SIM.
// |callback|: Called when the operation has completed.
static void unlockCellularSim(DOMString networkGuid,
DOMString pin,
optional DOMString puk,
optional VoidCallback callback);
// Sets whether or not SIM locking is enabled (i.e a PIN will be required
// when the device is powered) and changes the PIN if a new PIN is
// specified. If the new PIN is provided but not valid (e.g. too short)
// the operation will fail. This will not lock the SIM; that is handled
// automatically by the device. NOTE: If the SIM is locked, it must first be
// unlocked with unlockCellularSim() before this can be called (otherwise it
// will fail and $(ref:runtime.lastError) will be set to Error.SimLocked).
// |networkGuid|: The GUID of the cellular network to set the SIM state of.
// If empty, the default cellular device will be used.
// |simState|: The SIM state to set.
// |callback|: Called when the operation has completed.
static void setCellularSimState(DOMString networkGuid,
CellularSimState simState,
optional VoidCallback callback);
// Selects which Cellular Mobile Network to use. |networkId| must be the
// NetworkId property of a member of Cellular.FoundNetworks from the
// network properties for the specified Cellular network.
// |networkGuid|: The GUID of the cellular network to select the network
// for. If empty, the default cellular device will be used.
// |networkId|: The networkId to select.
// |callback|: Called when the operation has completed.
static void selectCellularMobileNetwork(DOMString networkGuid,
DOMString networkId,
optional VoidCallback callback);
// Gets the global policy properties. These properties are not expected to
// change during a session.
static void getGlobalPolicy(GetGlobalPolicyCallback callback);
// Gets the lists of certificates available for network configuration.
static void getCertificateLists(GetCertificateListsCallback callback);
};
interface Events {
// Fired when the properties change on any of the networks. Sends a list of
// GUIDs for networks whose properties have changed.
static void onNetworksChanged(DOMString[] changes);
// Fired when the list of networks has changed. Sends a complete list of
// GUIDs for all the current networks.
static void onNetworkListChanged(DOMString[] changes);
// Fired when the list of devices has changed or any device state properties
// have changed.
static void onDeviceStateListChanged();
// Fired when a portal detection for a network completes. Sends the guid of
// the network and the corresponding captive portal status.
static void onPortalDetectionCompleted(DOMString networkGuid,
CaptivePortalStatus status);
// Fired when any certificate list has changed.
static void onCertificateListsChanged();
};
};