shill/doc/manager-api.txt

Manager hierarchy
=================

Service		org.chromium.flimflam
Interface	org.chromium.flimflam.Manager
Object path	/

Methods		dict GetProperties()

			Return the global system properties specified
			in the Properties section.

		void SetProperty(string name, variant value)

			Changes the value of the specified property. Only
			properties that are listed as read-write are
			changeable. On success a PropertyChanged signal
			will be emitted.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.InvalidProperty

		object CreateProfile(string name)

			Create and add new profile with the specified
			identifier name.  The name should either be in the
			form ``name'' or ``~user/name'' where where ``user''
			is the login name of a user suitable for finding
			their home directory.  Both strings must contain
			only alpha-numeric ASCII characters.

			Profiles created without a user name are stored in
			a system directory readable only by the connection
			mananger.  Profiles created with a user name are
			stored in the user's home directory but readable
			only by the connection manager.

			If any existing profile is specified its contents
			are reset to a default (minimal) contents.  If the
			profile is already registered with a CreateProfile
			or PushProfile request then an error is returned.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.AlreadyExists

		object PushProfile(string name)

			Push the profile with the specified identifier
			onto the profile stack.  The profile must have
			previously been created with CreateProfile.
			The profile becomes the ``active profile'' that
			is searched first when loading data and to which
			updates are stored.

			A profile may be pushed only once.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.AlreadyExists

		object InsertUserProfile(string name, string user_hash)

			Add the profile with the specified identifier
			to the profile stack.  The profile must have
			previously been created with CreateProfile.
			The |user_hash| provided is assigned to the
			profile and is made visible as a property of
			the profile.

			A profile may be inserted or pushed only once.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.AlreadyExists

		object PopProfile(string name)

			Pop the top-most profile on the profile stack.
			Any profile beneath this profile becomes the
			``active profile''.  Any services using configuration
			from the popped profile are disconnected and the
			credentials invalidated (the next time
			credentials are needed they are loaded from the
			(new) active profile).

			The name must match the identifier of the active
			profile.  This is a safeguard against accidentally
			removing the wrong profile.

			Note it is valid to pop all profiles from the
			stack; in this state the connection manager does
			not write any state to persistent storage.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.NotFound
					 [service].Error.WrongState

		object PopAnyProfile()

			Like PopProfile but do not check the profile on
			the top of the stack; pop anything.

			Possible Errors: [service].Error.InvalidArguments

		object PopAllUserProfiles()

			Remove all user profiles from the stack of managed
			profiles leaving only default profiles if any exist.

		void RemoveProfile(string name)

			Remove the profile with specified identifier.

			The profile may not be resident on the stack.
			The default profile may not be removed.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.AlreadyExists

		void RequestScan(string type)

			Request a scan for each device of the specified
			technology.  If type is the string "" then a scan
			request is made for each technology.

			For WiFi devices this triggers a search for
			available WiFi networks.  When results are
			available, the Device.Networks property is
			updated and a PropertyChanged signal is issued.

			For cellular devices, this triggers a search for
			available cellular networks, which may take up to a
			minute or two to complete.  When the results are
			available, the Cellular.FoundNetworks property of
			each cellular device is set with the results.

			Possible Errors: [service].Error.InvalidArguments

		void EnableTechnology(string type)

			Enable all technologies of the specified type.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.InProgress
					 [service].Error.AlreadyEnabled
					 [service].Error.PermissionDenied

		void DisableTechnology(string type)

			Disable all technologies of the specified type.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.InProgress
					 [service].Error.AlreadyDisabled

		object ConfigureService(dict properties)

			Update the configuration of a service in memory
			and in the profile.  If no matching service exists
			in memory it is temporarily created to carry out
			this work and may be removed later.  The object
			path of the created service is returned.

			If a GUID property is specified in properties
			it is used to find the service; otherwise Type,
			SecurityClass, and type-specific properties such as
			WiFi.SSID are used to find any existing service.
			If no service is located in memory a new one is
			created with the supplied properties.

			All provided parameters are applied to the in
			memory service regardless of errors.  But if an
			error occurs while setting a property and the
			service object was created as a result of this
			call it is removed.  In the event of multiple
			errors the first error code is returned by
			this call.

			See the Service Properties section for a list of
			properties and constraints on property values.
			See also GetService.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.TechnologyNotAvailable

		object ConfigureServiceForProfile(object profile,
						  dict properties)

			Create or update the configuration of a WiFi
			service within a specific profile.  This is
			similar to "ConfigureService" above, except
			that this might not change the state of the
			current service.  A matching service is found
			by first looking for a service with matching
			"GUID" property if specified, then by using
			the "Mode", "SSID", and "SecurityClass" properties
			from |properties|.

			If a matching service is found but its current
			profile supersedes the specified profile, a new
			profile entry is written with the specified
			properties.  This method can be used for
			configuring a service in the default profile
			while a separate configuration exists in the
			user profile.  In this scenario, no configured
			properties in the user profile entry will be
			copied to the default profile, and the user
			profile remains unchanged.  Moreover, the
			matching service will still refer to the user
			profile.

			A second example usage for this method is creating
			a copy of the current service from the default
			profile into the user profile.  If a matching
			service exists but its current profile antecedes
			the specified profile, the configuration of the
			current service is first copied to the new profile
			without removing the entry in the default profile.
			The service is then assigned to the new profile
			and the specified properties are then applied to
			the service and saved to the new profile, leaving
			the original profile intact.  This differs from the
			behavior of setting the "Profile" property on the
			service via the SetProperty or ConfigureService
			methods, which remove the configuration from the
			old profile.

			In situations where a matching service is not found,
			the service isn't associated with a profile, or the
			specified profile is already associated with the
			matched service, the behavior of this method mimics
			that of ConfigureService.

			Currently this method is only supported for WiFi
			services.  The specified profile must already
			be loaded and on the Manager's profile stack.
			If the "Profile" parameter is set in the properties
			dictionary, it must match the profile parameter.

			This method returns the object path of the created
			or modified service, in cases where a matching
			service will refer to the specified profile.
			Otherwise it returns the special path "/" to signify
			that although the operation succeeded, there is
			no matching service that refers to this profile.

			Possible Errors: [service].Error.IllegalOperation
					 [service].Error.InternalError
					 [service].Error.InvalidArguments
					 [service].Error.NotFound
					 [service].Error.TechnologyNotAvailable

		void FindMatchingService(dict properties)

			Find a service that matches all the properties
			and returns the object identifier associated
			with it.  If no service exists in memory that
			matches these arguments, an error is returned.

			See also GetService and ConfgiureService.

			Possible Errors: [service].Error.NotFound

		object GetService(dict properties)

			Return the object path of a service after
			applying any requested configuration changes.
			If no service exists it is created.

			If a GUID property is specified in properties
			it is used to find the service; otherwise Type,
			Security, and type-specific properties such as
			WiFi.SSID are used to find any existing service.
			If no service is located in memory a new one is
			created with the supplied properties.

			All provided parameters are applied to the service
			regardless of errors.  But if an error occurs
			while setting a property and the service was
			created as a result of this call it is removed.
			In the event of multiple errors the first error
			code is returned by this call.

			See the Service Properties section for a list of
			properties and constraints on property values.
			See also ConfigureService.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.PermissionDenied
					 [service].Error.InternalError
					 [service].Error.InvalidNetworkName
					 [service].Error.InvalidPassphrase
					 [service].Error.TechnologyNotAvailable

		void SetDebugTags(string taglist)

			Set the debug tags that are enabled for logging to
			syslog. "taglist" is a list of valid tag names
			separated by "+".  Shill silently ignores
			invalid flags.

		string GetDebugTags()
			Get the list of enabled debug tags. The list is
			represented as a string of tag names separated
			by "+".

		string ListDebugTags()
			Get the list of all debug tags that can be enabled.
			The list is represented as a string of tag names
			separated by "+".

		string GetServiceOrder()

			Return a ','-separated string listing known technologies
			in priority ordering.

			For example, the default ordering would be returned as:
				"ethernet,wifi,cellular"

		void SetServiceOrder(string mask)

			Set the technology priority based on a provided
			','-separated list of technologies, sorted from highest
			priority to lowest.

			The list may contain the following services:
				{ ethernet, wifi, cellular }
			Technologies not included are assigned the lowest
			priority.

			Technology priority changes occur immediately.

			Possible Errors: [service].Error.InvalidArguments

		void RecheckPortal()

			Deprecated: Use Service.RequestPortalDetection instead.
			Retest the portal state of all connected services
			if a check is not currently in progress.

		dict GetNetworksForGeolocation()

			Deprecated: Use Manager.GetCellularNetworksForGeolocation()
			and Manager.GetWiFiNetworksForGeolocation() instead.
			Returns a dictionary (array of dictionary entries)
			containing information about visible cellular and WiFi
			networks which may be then used for Geolocation.
			Each key is a string representing a network type (cellular
			or WiFi), and the value itself is an array of dictionaries
			mapping string key-value pairs. Each of these
			(sub) dictionaries contains information about one single
			network for Geolocation.
			If there are several network devices of a particular
			type, this method will return all of the information
			from all of the devices.
			For more details, see:
			https://developers.google.com/maps/documentation/business/geolocation/

		dict GetCellularNetworksForGeolocation()

			Returns a dictionary (array of dictionary entries)
			containing information about visible cellular networks which
			may be then used for Geolocation.
			The key is a string representing cellular network type, and
			the value itself is an array of dictionaries mapping string
			key-value pairs. Each of these (sub) dictionaries contains
			information about one single cellular network for
			Geolocation.
			If there are several cellular devices, this method will
			return all of the information from all of the cellular
			devices.
			For more details, see:
			https://developers.google.com/maps/documentation/business/geolocation/

		dict GetWiFiNetworksForGeolocation()

			Returns a dictionary (array of dictionary entries)
			containing information about visible WiFi networks which may
			be then used for Geolocation.
			The key is a string representing WiFi network type, and the
			value itself is an array of dictionaries mapping string
			key-value pairs. Each of these (sub) dictionaries contains
			information about one single WiFi network for Geolocation.
			If there are several WiFi devices, this method will return
			all of the information from all of the WiFi devices.
			For more details, see:
			https://developers.google.com/maps/documentation/business/geolocation/

		boolean SetNetworkThrottlingStatus(bool enabled,
						   uint32 upload_rate_kbits,
						   uint32 download_rate_kbits)

			Enables or disables network throttling to limit bandwidth
			consumed by the device. Applies to all interfaces. Both
			rates are specified in kbits/s. If throttling already
			exists, this will override current throttling settings.

		void ScanAndConnectToBestServices()

			Forces a WiFi scan if a WiFi device is available as a
			way of ensuring that networks recently configured can be
			found. Then connects to the highest priority service
			available for each technology as determined by sorting
			all services independent of their current connectivity
			state. Shill does not normally disrupt an active
			connection for a given technology, even when a higher
			priority network becomes available for that technology.
			Calling this method will trigger a switch to higher
			priority services for each available technology.
			Note: The scan applies only to a WiFi device, however
			connecting to the highest priority service will happen
			for all technologies.

		void CreateConnectivityReport()

			For each connected service, perform a single
			connectivity trial and report the results to the log.
			This connectivity test does not affect Service state.

		void ClaimInterface(string claimer_name, string interface_name)

			Claim the ownership of a device |interface_name|. The
			specified device will be added to the block list. Any
			current connection on that device will be terminated,
			and shill will stop managing that device. |claimer_name|
			is deprecated and thus can be any value.

		void ReleaseInterface(string claimer_name, string interface_name)

			Release the ownership of a device |interface_name| back
			to shill. The specified device will be removed from the
			block list and managed by shill. |claimer_name| is
			deprecated and thus can be any value.

		void SetDNSProxyAddresses(array{string} addresses)

			Assigns the IPv4 and IPv6 addresses of the dns-proxy
			service. When set, shill will use these addresses as
			the system name servers rather than those specified by
			the relevant service.

			If the array is empty, DNS proxy address(es) will be
			cleared and the name servers from the current default
			network will be used. This is the same behavior as
			ClearDNSProxyAddresses.

			This IPv4 address is enforced to be within a predetermined
			system local subnet.

		void ClearDNSProxyAddresses()

			Clear any DNS proxy address stored in shill. When this
			is called, shill will use the name servers from the
			current default network for /etc/resolv.conf instead of
			the proxy address(es).

		void DNSProxyDOHProviders(array{string, string} providers)

			Assigns the DNS-over-HTTPS service providers for use by
			the dns-proxy service. URLs of the secure
			DNS service endpoints are used as keys. If applicable,
			each value is a comma-separated list of the IP addresses
			(both v4 and v6 are supported) of the standard DNS name
			servers that map to the secure DNS service provider.

		void AddPasspointCredentials(object profile, dict properties)

			Adds a set of Passpoint credentials to |profile|. The credentials
			will be used to match and connect to compatible Wi-Fi networks.
			Credentials cannot be added to the default Profile.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.NotFound
					 [service].Error.OperationFailed

		void RemovePasspointCredentials(object profile,
	                                        dict properties)

			Remove Passpoint credentials that matches the all
			property of |properties|. This removes all services
			associated with the removed credentials.

			Possible Errors: [service].Error.InvalidArguments
					 [service].Error.NotFound
					 [service].Error.OperationFailed

		void SetTetheringEnabled(boolean enabled)

			DEPRECATED - Use EnableTethering and DisableTethering instead.

			Enables or disables tethering with the corresponding properties in
			Manager.TetheringConfig. Only supports cellular and ethernet as the
			upstream technologies. Only supports WiFi as the downstream technology.
			Returns a string indicating the result. This could be any one of,
			"success", "failure", "not_allowed", "invalid_properties", "abort",
			"upstream_not_available", "downstream_wifi_failure", "wrong_state"
			"network_setup_failure", "upstream_failure", "busy",
			"concurrency_not_supported".

		void EnableTethering(WiFiInterfacePriority priority)

			Enables tethering with the corresponding properties in
			Manager.TetheringConfig. Only supports cellular and ethernet as the
			upstream technologies. Only supports WiFi as the downstream technology.
			Returns a string indicating the result. This could be any one of,
			"success", "failure", "not_allowed", "invalid_properties", "abort",
			"upstream_not_available", "downstream_wifi_failure", "wrong_state"
			"network_setup_failure", "upstream_failure", "busy".

			"priority" arg designates the priority of the underlying SoftAP
			interface. It is currently stubbed and non-functional.

		void DisableTethering()

			Disables tethering with the corresponding properties in
			Manager.TetheringConfig. Only supports cellular and ethernet as the
			upstream technologies. Only supports WiFi as the downstream technology.
			Returns a string indicating the result. This could be any one of,
			"success", "failure", "not_allowed", "invalid_properties", "abort",
			"upstream_not_available", "downstream_wifi_failure", "wrong_state"
			"network_setup_failure", "upstream_failure", "busy".

		string CheckTetheringReadiness()

			Checks whether the upstream technology is ready to tether. It checks,
			1. If any upstream is connected.
			2. For cellular upstream, performs an entitlement check with the
			carrier, and check to see if there is a known tethering APN
			that can be used.
			Returns a status string indicating the readiness. Possible status:
			"ready", "not_allowed", "upstream_network_not_available".

		void SetLOHSEnabled(boolean enabled)

			Enables or disables local only hotspot with the corresponding properties in
			Manager.LOHSConfig. Returns a string through an asynchronous callback
			indicating the result. This currently only returns "NotImplemented".

		void SetCapportEnabled(boolean enabled)

			Enables or disables the CAPPORT functionality for all network instances.
			After it's disabled, the network validation will skip CAPPORT query.
			When it becomes enabled, the networks that have been detected the
			CAPPORT server will schedule the validation automatically.

		dict CreateP2PGroup(dict properties)

			Creates a P2P group with the specified config with this device as
			the group owner. Possible arguments are "ssid" (string),
			"passphrase" (string), "frequency" (int32), and "priority"
			(WiFiInterfacePriority). "priority" is mandatory. All other
			arguments are optional and all omitted args will be chosen by the
			platform.

			Returns a dictionary with the following entries:

			"result_code" (string): A string indicating the result of the
			operation. This could be any one of "success", "not_allowed",
			"not_supported", "concurrency_not_supported", "timeout",
			"frequency_not_supported", "bad_ssid", "invalid_arguments",
			"operation_in_progress", "operation_failed".

			"shill_id" (uint32): Only included when result_code == "success".
			Unique ID for the newly formed P2P group.

			Some functionality is stubbed.

		dict ConnectToP2PGroup(dict properties)

			Starts a P2P connection with a P2P group with the specified
			config. Possible arguments are "ssid" (string), "passphrase"
			(string), "frequency" (int32), and "priority" (WiFiInterfacePriority).
			"ssid", "passphrase", and "priority" are mandatory. If "frequency" is
			omitted then the platform will scan all available channels.

			Returns a dictionary with the following entries:

			"result_code" (string): A string indicating the result of the
			operation. This could be any one of "success", "not_allowed",
			"not_supported", "concurrency_not_supported", "timeout",
			"auth_failure", "frequency_not_supported",  "group_not_found",
			"already_connected", "invalid_arguments", "operation_in_progress",
			"operation_failed".

			"shill_id" (uint32): Only included when result_code == "success".
			Unique ID for the newly created P2P client.

			Some functionality is stubbed.

		dict DestroyP2PGroup(uint32 shill_id)

			Destroys the P2P group with the specified shill_id. Prior to
			destruction of the group, all P2P clients connected to the group
			will be disconnected.

			Returns a dictionary with the following entries:

			"result_code" (string): A string indicating the result of the
			operation. This could be any one of "success", "not_allowed",
			"not_supported", "timeout", "no_group", "operation_in_progress",
			"operation_failed".

			"shill_id" (uint32): Unique ID for the requested P2P client.

			Some functionality is stubbed.

		dict DisconnectFromP2PGroup(uint32 shill_id)

			Disconnects the P2P client with the specified shill_id from it's
			P2P group.

			Returns a dictionary with the following entries:

			"result_code" (string): A string indicating the result of the
			operation. This could be any one of "success", "not_allowed",
			"not_supported", "timeout", "not_connected", "operation_in_progress",
			"operation_failed".

			"shill_id" (uint32): Unique ID for the requested P2P client.

			Some functionality is stubbed.

Signals		PropertyChanged(string name, variant value)

			This signal indicates a changed value of the given
			property.

Properties	object ActiveProfile [readonly]

			Object path of the top-most Profile in the Profile stack.

		string AlwaysOnVpnPackage [readwrite]

			Package name of an Android VPN app to use as the "AlwaysOnVpn"
			connection. When this property is not "", all user traffic will be
			blackholed unless we are connected to an ARC VPN using the
			corresponding Android app.

		boolean ArpGateway [readwrite]

			Specifies whether the DHCP client should be configured to perform
			the extra step of performing an ARP of the gateway IP address.  This
			provides a level of assurance that the issued IP address is valid
			and not blocked in some manner unknown by the DHCP server.

		array{string} AvailableTechnologies [readonly]

			The list of technologies for which at least one Device exists (see
			the caveat in Devices). Order carries no meaning and is not
			guaranteed to be consistent.

		string CheckPortalList [readwrite]

			The list of technologies for which "captive portal checking"--really
			just connectivity quick checks--is enabled.  This is a
			comma-separated string; e.g. "wifi,cellular,vpn".

		array{string} ClaimedDevices [readonly]

			The list of the names of devices that have been claimed
			by an external service for management by ClaimInterface method.

		array{string} ConnectedTechnologies [readonly]

			The list of technologies for which at least one Device is connected
			(see the caveat in Devices). Order carries no meaning and is not
			guaranteed to be consistent.

		string ConnectionState [readonly]

			The state of the highest ranked connected service.  The value of
			this property is "idle" if there are no connected services.
			Otherwise this can be any of the connected service states, e.g,
			"ready" or "online".

		object DefaultService [readonly]

			The object path of the connected Service with the highest
			priority. If there is no connected Service, returns the "/" object
			path.

		string DefaultTechnology [readonly]

			The technology of the DefaultService.

		array{object} Devices [readonly]

			List of physical Device object paths. No virtual Devices are
			contained in this list. Order carries no meaning and is not guaranteed
			to be consistent.

		string DHCPProperty.Hostname [readwrite]

			Optional setting to configure DHCP requests.  Some DHCP servers may
			register a DNS entry on behalf of this hostname; others may just
			make available a table for administrators to tell what machines are
			on their network.

			The default for this name is empty, which means that the system will
			not report a hostname.  When this property is set it will be
			persisted in the default profile.

		bool DisableVHT [readwrite]

			Disables 802.11ac Very High Throughput (VHT) connections, reverting
			to 802.11n.

		string DisconnectWiFiOnEthernet [readwrite]

			Option to auto disconnect WiFi and inhibit WiFi autoconnect when an
			Ethernet service is available. Setting value to "connected" configure
			shill to disconnect WiFi when basic network provisioning is done on
			Ethernet, while setting value to "online" only disconnect WiFi when
			Internet reachability is verified on Ethernet. Setting value to "off"
			turns off this feature. "off" by default.

		array{string} EnabledTechnologies [readonly]

			The list of technologies for which at least one Device is enabled
			(see the caveat in Devices). Order carries no meaning and is not
			guaranteed to be consistent.

		boolean EnableDHCPQoS [readwrite]

			If set, shill will instruct dhcpcd to apply proper DSCP value on all
			egress DHCP packets. Currently this option only affects the DHCP packets
			on the WiFi networks.

		boolean EnableRFC8925 [readwrite]

			Specify whether DHCPv4 client should follow RFC 8925 to request option
			108, which will in result volunteer to drop IPv4 and prefer operating as
			IPv6-only, if the network itself is also IPv6-only capable.

		dict LOHSConfig [readwrite]

			Dictionary that contains the following Local Only HotSpot (LOHS) related
			properties. This intentionally mirrors the Manager.TetheringConfig and
			reuses the same Manager.TetheringConfig property names.

			string ssid
				the hex-encoded tethering SSID name to be advertised
			string band
				the local only hotspot band preference. This should be either
                                “2.4GHz” or “5GHz”. If absent, the band will be picked by Shill.
			string security
				the tethering security to be used. This should be "wpa2"
			string passphrase
				the password to be used to authenticate to the local only hotspot
				network

		string NoAutoConnectTechnologies [readwrite]

			The list of technologies for which auto-connect is disabled. This is
			a comma-separated string, e.g. "cellular,wifi".

		dict P2PCapabilities [readonly]

			A property that indicates the hardware capabilities and state
			information for P2P operation on the platform. Callers should
			request this property before utilizing the P2P API.

			boolean P2PSupported
				Whether the platform supports P2P operations.

			string GroupReadiness
				Indicates whether the platform is currently able to support
				a new P2P Group Owner interface. Options: "ready", "not_ready".

			string ClientReadiness
				Indicates whether the platform is currently able to support
				a new P2P Client interface. Options: "ready", "not_ready".

			array{int} SupportedChannels
				This provides the list of supported channel frequencies in MHZ.
				Note: On Android the GC can use indoor channels by GO cannot,
				so sending the supported channels for GO role should be done
				here.

			array{int} PreferredChannels
				This provides a list of channels that the platform would
				prefer the P2P link to be created on. An empty list indicates
				no preference. These are not ordered, so all “preferred”
				channels should have equal priority.

		array{dict} P2PClientInfos [readonly]

			List of all P2P Client interfaces that are active on the platform.
			The format for representation of a local P2P Client interface:

			uint32_t shill_id
				Unique ID to represent the P2P Client, provided by Shill.
				This is only used to disambiguate the group against other
				P2P Clients on the platform and has no relation to any other
				identifiers such as P2P Group ID, BSSID, mac address,
				interface index, etc.

			string state
				Current state of a local P2P Client interface. Possible values:

				"idle"
					No connectivity with the Group has been established.

				"associating"
					In the process of associating and establishing
					L2 connectivity to the Group.

				"configuring"
					L2 connectivity established, in the process of
					configuring L3 connectivity.

				"connected"
					Device has established L3 connectivity.

				"disconnecting"
					In the process of disconnecting from the Group.

			string ssid
				The SSID of the network to which the Client is connected,
				or connecting.

			string passphrase (type:string)
				The passphrase of the network to which the Client is connected,
				or connecting.

			string group_bssid
				The BSSID of the P2P Group Owner.

			string ipv4_address [optional]
				This represents the ipv4 address of the local client interface
				in its textual representation.

			string ipv6_address [optional]
				This represents the ipv6 addresses of the local client interface
				in its textual representation.

			string mac_address
				The MAC address of the local client interface with format
				in its textual representation.

			int frequency
				This represents the selected channel on which the network
				is hosted.

			int32_t network_id
				Unique ID to identify the network.

			string interface
				The client's interface name (for example "p2p-wlan0-0").

			dict group_owner
				Representation of the Group Owner to which the Client is
				connecting, or connected. This dictionary has the following
				entries:

				string mac_address
					The MAC address of the Group Owner interface
					in its textual representation.

				string ipv4_address
					The IPv4 address of the Group Owner interface
					in its textual representation.

				array{string} ipv6_addresses
					The IPv6 addresses of the Group Owner interface.
					Unused in the MVP, but defined here for forward
					compatibility.

				string hostname [optional]
					This represents the host name of the Group Owner
					which may or may not be NULL.

				string vendor_class [optional]
					The vendor class value that the client may choose
					to advertise. For example Chrome OS devices advertise
					“chromeos”.

		array{dict} P2PGroupInfos [readonly]
			List of all local P2P Group Owner interfaces that are active
			on the platform. The format for representation of a local
			P2P Group Owner interface:

			uint32_t shill_id
				Unique ID to represent the Group, provided by Shill.
				This is only used to disambiguate the group against other
				P2P Groups on the platform and has no relation to any other
				identifiers such as P2P Group ID, BSSID, mac address,
				interface index, etc.

			string state
				Current state of a local P2P Group Owner interface.
				Possible values:

				"idle"
					The interface is not ready to accept clients.

				"starting"
					The interface is in the process of forming the group.

				"configuring"
					The group is formed at link layer, in the process
					of setting up network configuration.

				"active"
					The group is fully formed and ready to accept clients.

				"stopping"
					The group is in the process of being torn down
					and destroyed.

			string ssid
				The SSID of the group hosted by the local interface.

			string passphrase
				The passphrase of the group hosted by the local interface.

			string bssid
				The BSSID of the P2P Group Owner.

			string ipv4_address [optional]
				This represents the ipv4 address of the local interface
				in its textual representation.

			array{string} ipv6_addresses
				This represents the ipv6 addresses of the local interface
				in its textual representation.

			string mac_address
				The MAC address of the local interface with format
				in its textual representation.

			int frequency
				This represents the selected channel on which the group
				is hosted.

			int32_t network_id
				Unique ID to identify the network in Patchpnel.

			string interface
				The group's interface name (for example "p2p-wlan0-0").

			array{dict} clients
				A list of clients of the P2P group. Each of these dictionaries
				has the following entries:

				string mac_address
					The MAC address of the client interface
					in its textual representation.

				string ipv4_address
					The IPv4 address of the client interface
					in its textual representation.

				string ipv6_address [optional]
					The IPv6 addresses of the P2P Client. Unused in the MVP,
					but defined here for forward compatibility.

				string hostname [optional]
					This represents the client host name.

				string vendor_class [optional]
					The vendor class value that the client may choose
					to advertise. For example Chrome OS devices advertise
					“chromeos”.

		string PortalFallbackHttpUrls [readwrite]

			Comma-separated string of URLs used for HTTP connectivity
			verification after the first connectivity verification trial. The
			order of these URLs has no meaning.

		string PortalFallbackHttpsUrls [readwrite]

			Comma-separated string of URLs used for HTTPS connectivity
			verification after the first connectivity verification trial. The
			order of these URLs has no meaning.

		string PortalHttpUrl [readwrite]

			The first URL to use when doing connectivity verification over HTTP.
			If portal detection fails with this URL, an entry in
			PortalFallbackHTTPUrls will be used.

		string PortalHttpsUrl [readwrite]

			The first URL to use when doing connectivity verification over
			HTTPS. If portal detection fails with this URL, an entry in
			PortalFallbackHTTPSUrls will be used.

		string ProhibitedTechnologies [readwrite]

			The list of technologies whose Devices should be disabled and
			prohibited from being enabled. This is a comma-separated string,
			e.g. "cellular,wifi". All Devices that are one of these technology
			types will be immediately disabled persistently, and when a new
			Device of this type appears, it will be disabled by default.
			Attempts to enable such a Device using the EnableTechnology will
			fail. Order carries no meaning and is not guaranteed to be
			consistent.

		array{object} Profiles [readonly]

			List of Profile object paths in the Profile stack. Elements are
			ordered from top of the stack to bottom.

		array{object} Services [readonly]

			List of Service object paths that are visible. The first Service is
			always the primary connected Service on the system (if there is
			one). Services in a more connected state always come before Services
			in a less connected state. In order:
			  * "online"
			  * "ready"
			  * "no-connectivity", "redirect-found", or "portal-suspected"
			  * "association" or "configuration"
			  * "idle" or "disconnecting"
			  * "failure"

			Between unconnected Services, connectable Services come before
			unconnectable Services. Within the same state "bucket", Services are
			ordered based on Technology type (see SetServiceOrder). Services in
			the same state bucket and with the same Technology type are then
			compared with the following (in order):
			  * "Priority"
			  * "Source"
			  * "ManagedCredentials"
			  * "AutoConnect"
			  * "Security" (currently only for WiFi)
			  * "Profile" ordering
			  * If the Service has ever connected
			  * "Strength"

			Finally, if two Services have all of those in common, the Service
			that was created first will be placed before the other Service.

			This list represents the available services for the current selected
			profile. If the profile gets changed then this list will be updated.

			The same list is available via the profile object itself. It is just
			provided here for convenience of applications only dealing with the
			current active profile.

		array{object} ServiceCompleteList [readonly]

			Complete list of Service object paths, including those that are not
			currently visible.  For example, WiFi Services that are stored in a
			loaded Profile but cannot currently be connected are presented in
			this list.

			The Services are listed in the same Service sorting order as the
			"Services" property above.  Change events for this property are not
			emitted.

		array{object} ServiceWatchList [readonly]

			List of Service object paths that are in a 'non-idle' state. This
			indicates the set of Services which are currently listed as
			associating, configuring, or some other state other than idle,
			failure, disconnecting, or unknown.  This allows a caller to use
			this property indication to track which Services should be monitored
			for state changes.

			The Services are listed in the same Service sorting order as the
			"Services" property above, and a change event for this property is
			emitted every time the Service list is reordered, even if this list
			has not changed.

		string SupportedVPNTypes [readonly]

			The list of supported vpn types. This is a comma-separated string;
			e.g. "l2tpipsec,openvpn,thirdpartyvpn,arcvpn". The possible value of
			list items are "l2tpipsec", "openvpn", "thirdpartyvpn", "arcvpn", and
			"wireguard".

		boolean TetheringAllowed [readwrite]

			Whether tethering feature is allowed. When false, SetTetheringEnabled
			will return failure. The value is controlled by a feature flag in Chrome.
			Should only be modified by Chrome feature flag or tests.

		boolean ExperimentalTetheringFunctionality [readwrite]

			Whether the tethering feature is allowed on untested carriers,
			modems and modem FW versions. When false, tethering is only allowed
			in tested carriers/modems/FWs; when true, the feature is allowed in
			all of them, unless tethering is disallowed by the carrier.

		dict TetheringCapabilities [readonly]

			Dictionary containing the tethering hardware capabilities of the device.

			array{string} downstream_technologies
				array containing any/all of "wifi", "ethernet"
			array{string} upstream_technologies
				array containing any/all of "wifi", "cellular", "ethernet"
			array{string} wifi_security_modes
				array containing any/all of "wpa2", "wpa3" or "wpa2+wpa3"

		dict TetheringConfig [readwrite]

			Dictionary that contains the following Tethering related properties.
			Changing this property while a tethering session is active will restart
			the tethering session with new configs. If upstream_technology is not
			changed and is cellular, the upstream network will remain unchanged
			during the tethering restart process. If only auto_disable is changed,
			inactivity timer will be armed/disarmed on the fly. The tethering
			session will not be restarted.

			boolean auto_disable
				automatically disable tethering if no devices have been
				associated for 10 minutes. Default to true.
			boolean MAR
				a random MAC address is used when a mobile AP is started
				(WiFi downstream only). Default to true.
			string ssid
				the hex-encoded tethering SSID name to be advertised (WiFi
				downstream only)
			string band
				the tethering band preference (WiFi downstream only)
				this should be either “2.4GHz” or “5GHz”. If absent, the band will
				be picked by the platform.
			string security
				the tethering security to be used (WiFi downstream only)
				this should be one of "wpa2", "wpa3", "wpa2+wpa3"
			string passphrase
				the password to be used to authenticate to the tethering network
				(WiFi downstream only)
			string upstream_technology
				Preferred upstream technology to use, one of "wifi", "cellular",
				"ethernet". If absent, Shill will use cellular as the default
				upstream technology.
			string downstream_device_for_test
				the assigned downstream device, only used for testing. This
				property is never persisted.
			uint32 downstream_phy_index_for_test
				The phy index of the assigned downstream device, only used for
				testing. This property is never persisted.

		dict TetheringStatus [readonly]

			Dictionary that contains the status of the active tethering connection,

			string downstream_technology
				one of "wifi", "ethernet".
			string upstream_technology
				one of "wifi", "cellular", "ethernet".
			string state
				state of the tethering instance. The state could be any one of
				"idle", "starting", "active", "stopping" or "restarting".
			string idle_reason
				the reason why tethering is in idle state. Could be any one of
				"initial_state", "client_stop", "user_exit", "inactive", "error"
				"upstream_disconnect", "upstream_no_internet", "suspend",
				"config_change", "downstream_link_disconnect", "start_timeout",
				"downstream_network_disconnect", "upstream_not_available",
				"concurrency".
			array{dict} active_clients
				string IPv4
					IPv4 address of the associated client expressed in the
					dotted-decimal format.
				array{string} IPv6
					IPv6 addresses of the associated client in allowed format
					as specified in RFC 2373.
				string MAC
					EUI-64 or EUI-48 hardware address of the associated client.
				string hostname
					hostname of the associated client. This value is present
					only if the client advertises it in its DHCP request.

		array{string} UninitializedTechnologies [readonly]

			The list of uninitialized technologies. An uninitialized technology
			is a technology that has at least one Device that is not initialized
			yet (i.e.  the Device object is not created yet). The strings are
			the same as the ones from the service types.

		bool WakeOnLanEnabled [readwrite]

			Specifies whether the Wake on LAN feature should be enabled on new
			Ethernet links. Currently connected links are un-affected.

		bool WiFi.GlobalFTEnabled [readwrite]

			Specifies whether or not 802.11r Fast BSS Transition should be
			used.

		bool WiFi.ScanAllowRoam [readwrite]

			Specifies whether or not a WiFi scan could trigger a
			roam if a better AP is found on the same network.

		string WiFi.RequestScanType [readwrite]

			Specifies WiFi RequestScan scan type.
			Possible values:

			"active"
				Active scan over all channels.

			"passive"
				Passive scan over all 6 GHz channels.

			"default"
				Rotates the scan type between active and passive scans.

		array{string, string} DNSProxyDOHProviders [readonly]

			The DNS-over-HTTPS service providers. URLs of the secure
			DNS service endpoints are used as keys. If applicable,
			each value is a comma-separated list of the IP addresses
			(both v4 and v6 are supported) of the standard DNS name
			servers that map to the secure DNS service provider.

		boolean P2PAllowed [readwrite]

			Whether P2P feature is allowed. When false, all P2P-related calls
			will return failure. Should only be modified by Chrome feature flag
			or tests.

Enums		WiFiInterfacePriority

			Represents the priority level of a Wi-Fi interface. When a new
			interface is requested, existing interfaces of lower priority may be
			destroyed to make room for the new interfaces.

			"OPPORTUNISTIC"
				Opportunistic requests with minimum priority; nice-to-have but
				don’t directly impact the user.

			"BACKGROUND"
				Background requests; not triggered by direct user input.

			"FOREGROUND_WITH_FALLBACK"
				Foreground requests with potential fallback media.

			"FOREGROUND_WITHOUT_FALLBACK"
				Foreground requests without any fallback media.

			"OS_REQUEST"
				Requests from OS-native applications like network settings that
				directly enable user use-cases.

			"USER_ASSERTED"
				 User-initiated requests in which the user has been explicitly
				 informed that some Wi-Fi functionality may stop working, and
				 agreed to start the interface anyway. Treated with maximum
				 priority.