cuttlefish Namespace Reference

Namespaces
namespace	anonymous_namespace{adb_connection_maintainer.cpp}
namespace	anonymous_namespace{alloc_netlink.cpp}
namespace	anonymous_namespace{alloc_utils.cpp}
namespace	anonymous_namespace{android_build_api.cpp}
namespace	anonymous_namespace{android_build_api_key.cc}
namespace	anonymous_namespace{android_build_api_test.cpp}
namespace	anonymous_namespace{android_build_string.cpp}
namespace	anonymous_namespace{android_build_url.cpp}
namespace	anonymous_namespace{android_composite_disk_config.cc}
namespace	anonymous_namespace{android_dist_build.cc}
namespace	anonymous_namespace{android_efi_loader.cc}
namespace	anonymous_namespace{android_product_dir.cc}
namespace	anonymous_namespace{ap_composite_disk.cc}
namespace	anonymous_namespace{archive.cpp}
namespace	anonymous_namespace{are_hard_linked.cc}
namespace	anonymous_namespace{assemble_cvd.cc}
namespace	anonymous_namespace{audio_handler.cpp}
namespace	anonymous_namespace{audio_mixer.cpp}
namespace	anonymous_namespace{auto_login.cc}
namespace	anonymous_namespace{avb.cpp}
namespace	anonymous_namespace{blank_data_image_mb.cc}
namespace	anonymous_namespace{boot_config.cc}
namespace	anonymous_namespace{boot_image.cc}
namespace	anonymous_namespace{boot_image_test.cc}
namespace	anonymous_namespace{boot_image_utils.cc}
namespace	anonymous_namespace{boot_state_machine.cc}
namespace	anonymous_namespace{bootconfig_args.cpp}
namespace	anonymous_namespace{bootloader.cc}
namespace	anonymous_namespace{buffered_zip_source.cc}
namespace	anonymous_namespace{buffered_zip_source_test.cc}
namespace	anonymous_namespace{bugreport.cpp}
namespace	anonymous_namespace{build_api_credentials.cc}
namespace	anonymous_namespace{build_api_flags.cc}
namespace	anonymous_namespace{build_api_test.cpp}
namespace	anonymous_namespace{build_archive.cc}
namespace	anonymous_namespace{build_super_image.cc}
namespace	anonymous_namespace{cache.cpp}
namespace	anonymous_namespace{cached_zip_source.cc}
namespace	anonymous_namespace{cached_zip_source_test.cc}
namespace	anonymous_namespace{caching_build_api.cpp}
namespace	anonymous_namespace{cas_downloader.cpp}
namespace	anonymous_namespace{cas_downloader_test.cpp}
namespace	anonymous_namespace{cas_flags.cc}
namespace	anonymous_namespace{cf_configs_instances.cpp}
namespace	anonymous_namespace{cf_graphics_configs.cpp}
namespace	anonymous_namespace{cf_security_configs.cpp}
namespace	anonymous_namespace{cf_vm_configs.cpp}
namespace	anonymous_namespace{chroot_test.cc}
namespace	anonymous_namespace{clean.cc}
namespace	anonymous_namespace{clear.cpp}
namespace	anonymous_namespace{combined_android_build.cc}
namespace	anonymous_namespace{combined_android_build_test.cc}
namespace	anonymous_namespace{command.cc}
namespace	anonymous_namespace{command_handler.cc}
namespace	anonymous_namespace{command_request.cpp}
namespace	anonymous_namespace{common.cpp}
namespace	anonymous_namespace{concat_test.cc}
namespace	anonymous_namespace{config.cpp}
namespace	anonymous_namespace{config_flag.cpp}
namespace	anonymous_namespace{container.cpp}
namespace	anonymous_namespace{container_test.cc}
namespace	anonymous_namespace{control_env_proxy_server.cpp}
namespace	anonymous_namespace{copy.cc}
namespace	anonymous_namespace{copy_test.cc}
namespace	anonymous_namespace{cpio.cc}
namespace	anonymous_namespace{cpio_test.cc}
namespace	anonymous_namespace{cpus.cc}
namespace	anonymous_namespace{crc.cpp}
namespace	anonymous_namespace{create.cpp}
namespace	anonymous_namespace{create_dynamic_disk_files.cc}
namespace	anonymous_namespace{credential_source.cc}
namespace	anonymous_namespace{crosvm_builder.cpp}
namespace	anonymous_namespace{crosvm_cpu.cpp}
namespace	anonymous_namespace{cuda_loader.cpp}
namespace	anonymous_namespace{curl_http_client.cc}
namespace	anonymous_namespace{custom_actions.cpp}
namespace	anonymous_namespace{cuttlefish_config.cpp}
namespace	anonymous_namespace{cuttlefish_config_instance.cpp}
namespace	anonymous_namespace{cvd_video_frame_buffer.cpp}
namespace	anonymous_namespace{cvdalloc.cpp}
namespace	anonymous_namespace{daemon.cc}
namespace	anonymous_namespace{data.cpp}
namespace	anonymous_namespace{data_image.cpp}
namespace	anonymous_namespace{data_image_policy.cc}
namespace	anonymous_namespace{data_policy.cc}
namespace	anonymous_namespace{de_android_sparse.cc}
namespace	anonymous_namespace{debug_reader.cc}
namespace	anonymous_namespace{defaults.cpp}
namespace	anonymous_namespace{device_metrics_orchestration.cc}
namespace	anonymous_namespace{disjoint_range_set.cc}
namespace	anonymous_namespace{disjoint_range_set_test.cc}
namespace	anonymous_namespace{disk_usage.cpp}
namespace	anonymous_namespace{display.cpp}
namespace	anonymous_namespace{display_proto.cc}
namespace	anonymous_namespace{display_test.cc}
namespace	anonymous_namespace{env.cpp}
namespace	anonymous_namespace{error_type.cc}
namespace	anonymous_namespace{event_devices.cpp}
namespace	anonymous_namespace{extra_kernel_cmdline.cc}
namespace	anonymous_namespace{fake_nftables_test.cc}
namespace	anonymous_namespace{fake_seek_test.cc}
namespace	anonymous_namespace{fd.cc}
namespace	anonymous_namespace{fetch.cpp}
namespace	anonymous_namespace{fetch_config_parser.cpp}
namespace	anonymous_namespace{fetch_config_parser_test.cc}
namespace	anonymous_namespace{fetch_conversion.cc}
namespace	anonymous_namespace{fetch_conversion.h}
namespace	anonymous_namespace{fetch_cvd.cc}
namespace	anonymous_namespace{fetch_cvd_parser.cc}
namespace	anonymous_namespace{fetch_metrics.cc}
namespace	anonymous_namespace{fetch_metrics_orchestration.cc}
namespace	anonymous_namespace{fetch_tracer.cpp}
namespace	anonymous_namespace{fetcher_config.cpp}
namespace	anonymous_namespace{file_monitor_source.cc}
namespace	anonymous_namespace{find_build_archive.cc}
namespace	anonymous_namespace{flag.cpp}
namespace	anonymous_namespace{flag_forwarder.cc}
namespace	anonymous_namespace{flags.cc}
namespace	anonymous_namespace{flags.cpp}
namespace	anonymous_namespace{flags_collector.cpp}
namespace	anonymous_namespace{from_gflags.cc}
namespace	anonymous_namespace{gce_environment.cc}
namespace	anonymous_namespace{generate_persistent_bootconfig.cpp}
namespace	anonymous_namespace{generate_persistent_vbmeta.cpp}
namespace	anonymous_namespace{gflags_compat.cpp}
namespace	anonymous_namespace{gflags_xml_parser_test.cpp}
namespace	anonymous_namespace{github_environment.cc}
namespace	anonymous_namespace{gnss_grpc_proxy.cpp}
namespace	anonymous_namespace{gpu_mode.cc}
namespace	anonymous_namespace{gpx_parser_test.cc}
namespace	anonymous_namespace{graphics_flags.cc}
namespace	anonymous_namespace{grpc_service_handler.cc}
namespace	anonymous_namespace{guest_config.cc}
namespace	anonymous_namespace{guest_conversion.cc}
namespace	anonymous_namespace{guest_conversion.h}
namespace	anonymous_namespace{guest_enforce_security.cc}
namespace	anonymous_namespace{help.cpp}
namespace	anonymous_namespace{help_format.cpp}
namespace	anonymous_namespace{hex.cpp}
namespace	anonymous_namespace{host_conversion.cc}
namespace	anonymous_namespace{host_conversion.h}
namespace	anonymous_namespace{host_info.cpp}
namespace	anonymous_namespace{host_metrics.cc}
namespace	anonymous_namespace{host_tool_target.cpp}
namespace	anonymous_namespace{http_client.cc}
namespace	anonymous_namespace{http_json.cc}
namespace	anonymous_namespace{http_string.cc}
namespace	anonymous_namespace{image_aggregator.cc}
namespace	anonymous_namespace{img_zip.cc}
namespace	anonymous_namespace{in_memory.cc}
namespace	anonymous_namespace{initialize_instance_composite_disk.cc}
namespace	anonymous_namespace{input_paths_provider.cc}
namespace	anonymous_namespace{instance_database.cpp}
namespace	anonymous_namespace{instance_manager.cpp}
namespace	anonymous_namespace{interrupt_listener.cpp}
namespace	anonymous_namespace{invoker.cc}
namespace	anonymous_namespace{is_google_corp.cpp}
namespace	anonymous_namespace{kernel.cc}
namespace	anonymous_namespace{kernel_args.cpp}
namespace	anonymous_namespace{kernel_log_monitor.cpp}
namespace	anonymous_namespace{kernel_module_parser_test.cc}
namespace	anonymous_namespace{kernel_ramdisk_repacker.cpp}
namespace	anonymous_namespace{key_equals_value.cc}
namespace	anonymous_namespace{key_equals_value_test.cc}
namespace	anonymous_namespace{kml_parser_test.cc}
namespace	anonymous_namespace{launch.cpp}
namespace	anonymous_namespace{launch_cvd_parser.cpp}
namespace	anonymous_namespace{length_test.cc}
namespace	anonymous_namespace{lint.cpp}
namespace	anonymous_namespace{load_configs.cpp}
namespace	anonymous_namespace{load_configs_parser.cpp}
namespace	anonymous_namespace{local_instance.cpp}
namespace	anonymous_namespace{local_instance_group.cpp}
namespace	anonymous_namespace{log_files.cpp}
namespace	anonymous_namespace{log_files_test.cpp}
namespace	anonymous_namespace{log_sources.cc}
namespace	anonymous_namespace{log_tee_creator.cpp}
namespace	anonymous_namespace{login.cpp}
namespace	anonymous_namespace{logs.cpp}
namespace	anonymous_namespace{lz4_legacy.cc}
namespace	anonymous_namespace{lz4_legacy_test.cc}
namespace	anonymous_namespace{main.cc}
namespace	anonymous_namespace{main.cpp}
namespace	anonymous_namespace{managed_stdio.cc}
namespace	anonymous_namespace{mcu.cpp}
namespace	anonymous_namespace{media.cpp}
namespace	anonymous_namespace{memory_mb.cc}
namespace	anonymous_namespace{metadata_format.cc}
namespace	anonymous_namespace{metrics_conversion.cc}
namespace	anonymous_namespace{metrics_data.cc}
namespace	anonymous_namespace{metrics_flags.cc}
namespace	anonymous_namespace{metrics_orchestration.cc}
namespace	anonymous_namespace{metrics_transmission.cc}
namespace	anonymous_namespace{metrics_transmitter.cc}
namespace	anonymous_namespace{metrics_writer.cc}
namespace	anonymous_namespace{misc_info.cc}
namespace	anonymous_namespace{misc_info_metadata.cc}
namespace	anonymous_namespace{netlink_client.cc}
namespace	anonymous_namespace{netlink_request.cc}
namespace	anonymous_namespace{netsim_server.cpp}
namespace	anonymous_namespace{network.cpp}
namespace	anonymous_namespace{network_flags.cpp}
namespace	anonymous_namespace{network_test.cpp}
namespace	anonymous_namespace{nft_rule.cc}
namespace	anonymous_namespace{nft_rule_test.cc}
namespace	anonymous_namespace{nftables_nft.cc}
namespace	anonymous_namespace{notification.cc}
namespace	anonymous_namespace{nvenc_capabilities.cpp}
namespace	anonymous_namespace{nvenc_loader.cpp}
namespace	anonymous_namespace{nvenc_video_encoder.cpp}
namespace	anonymous_namespace{oauth2_consent.cpp}
namespace	anonymous_namespace{open_wrt.cpp}
namespace	anonymous_namespace{openwrt_args.cpp}
namespace	anonymous_namespace{openwrt_control_server.cpp}
namespace	anonymous_namespace{operator_client.cpp}
namespace	anonymous_namespace{os_composite_disk.cc}
namespace	anonymous_namespace{override_bool_arg.cpp}
namespace	anonymous_namespace{packager.cc}
namespace	anonymous_namespace{parse.cc}
namespace	anonymous_namespace{parse_time_test.cc}
namespace	anonymous_namespace{pdu_format_builder.cc}
namespace	anonymous_namespace{pdu_format_builder_test.cc}
namespace	anonymous_namespace{physical_partitions.cc}
namespace	anonymous_namespace{power_btn.cpp}
namespace	anonymous_namespace{powerbtn_cvd.cc}
namespace	anonymous_namespace{powerwash.cpp}
namespace	anonymous_namespace{powerwash_cvd.cc}
namespace	anonymous_namespace{pretty_test.cc}
namespace	anonymous_namespace{process_monitor.cc}
namespace	anonymous_namespace{ps.cpp}
namespace	anonymous_namespace{qcow2.cc}
namespace	anonymous_namespace{read_window_view_test.cc}
namespace	anonymous_namespace{readable_source.cc}
namespace	anonymous_namespace{record_cvd.cc}
namespace	anonymous_namespace{remote_zip.cc}
namespace	anonymous_namespace{remote_zip_test.cc}
namespace	anonymous_namespace{request_context.cpp}
namespace	anonymous_namespace{required_directories.cc}
namespace	anonymous_namespace{reset.cpp}
namespace	anonymous_namespace{restart.cpp}
namespace	anonymous_namespace{restart_cvd.cc}
namespace	anonymous_namespace{restart_subprocesses.cc}
namespace	anonymous_namespace{result_test.cpp}
namespace	anonymous_namespace{retrying_http_client.cc}
namespace	anonymous_namespace{ring_buffer_manager.cpp}
namespace	anonymous_namespace{root_canal.cpp}
namespace	anonymous_namespace{run_cvd_proc_collector.cpp}
namespace	anonymous_namespace{screen_recording.cpp}
namespace	anonymous_namespace{screenshot_handler.cpp}
namespace	anonymous_namespace{secure_env_not_windows_main.cpp}
namespace	anonymous_namespace{secure_env_only_oemlock.cpp}
namespace	anonymous_namespace{secure_hals.cpp}
namespace	anonymous_namespace{seekable_source.cc}
namespace	anonymous_namespace{sensors_simulator.cpp}
namespace	anonymous_namespace{serialize_disjoint_range_set_test.cc}
namespace	anonymous_namespace{server.cpp}
namespace	anonymous_namespace{session_id.cc}
namespace	anonymous_namespace{setup.cc}
namespace	anonymous_namespace{shared_fd.cpp}
namespace	anonymous_namespace{should_color.cc}
namespace	anonymous_namespace{sms_sender_test.cc}
namespace	anonymous_namespace{snapshot.cpp}
namespace	anonymous_namespace{snapshot_utils.cc}
namespace	anonymous_namespace{socket2socket_proxy.cpp}
namespace	anonymous_namespace{sparse_image.cc}
namespace	anonymous_namespace{start.cpp}
namespace	anonymous_namespace{status.cpp}
namespace	anonymous_namespace{status_fetcher.cpp}
namespace	anonymous_namespace{stop.cpp}
namespace	anonymous_namespace{streamer.cpp}
namespace	anonymous_namespace{StringParse.cpp}
namespace	anonymous_namespace{struct_test.cc}
namespace	anonymous_namespace{substitute.cc}
namespace	anonymous_namespace{super_builder.cc}
namespace	anonymous_namespace{super_image.cc}
namespace	anonymous_namespace{super_image_mixer.cc}
namespace	anonymous_namespace{suspend_resume_handler.cpp}
namespace	anonymous_namespace{symlink_host_package.cc}
namespace	anonymous_namespace{system_image_dir.cc}
namespace	anonymous_namespace{target_files.cc}
namespace	anonymous_namespace{tee_logging.cpp}
namespace	anonymous_namespace{ti50_emulator.cpp}
namespace	anonymous_namespace{touchpad.cpp}
namespace	anonymous_namespace{tpm_attestation_record.cpp}
namespace	anonymous_namespace{tpm_keymaster_context.cpp}
namespace	anonymous_namespace{tpm_keymaster_enforcement.cpp}
namespace	anonymous_namespace{users.cpp}
namespace	anonymous_namespace{util.cc}
namespace	anonymous_namespace{uuid.cpp}
namespace	anonymous_namespace{vendor_boot_image_test.cc}
namespace	anonymous_namespace{vendor_dlkm_utils.cc}
namespace	anonymous_namespace{version.cpp}
namespace	anonymous_namespace{vhost_device_vsock.cpp}
namespace	anonymous_namespace{vhost_user_media_devices.cpp}
namespace	anonymous_namespace{webrtc_command_channel.cpp}
namespace	anonymous_namespace{webrtc_controller.cpp}
namespace	anonymous_namespace{wmediumd_server.cpp}
namespace	anonymous_namespace{xdg.cpp}
namespace	confui
namespace	contains_internal_impl
namespace	cvdalloc
namespace	http_client
namespace	internal
namespace	modem
namespace	monitor
namespace	oemlock
namespace	pci
namespace	process_sandboxer
namespace	run_cvd_impl
namespace	ScreenConnectorInfo
namespace	secure_env
namespace	secure_env_impl
namespace	selector
namespace	sensors
namespace	socket_proxy
namespace	transport
namespace	vhal_proxy_server
namespace	virtualtuner
namespace	vm_manager
namespace	webrtc_signaling
namespace	webrtc_streaming

Classes
class	AbgrBuffer
class	AdbConfig
class	AdbConfigFlag
class	AdbConfigFragment
class	AndroidBuild
class	AndroidBuildApi
struct	AndroidBuildKey
class	AndroidBuilds
class	AndroidBuildUrl
class	AndroidEfiLoaderEspBuilder
class	AndroidEfiLoaderFlag
class	AndroidSparseImage
class	ApBootloaderEnvPartition
class	ApCompositeDisk
class	ApPersistentVbmeta
struct	AttestationIds
class	AudioClientConnection
class	AudioCommand
class	AudioHandler
class	AudioMixer
struct	AudioMixerSettings
class	AudioServer
class	AudioServerExecutor
struct	AudioStreamSettings
class	Avb
class	AvbParser
class	BlankDataImageMbFlag
class	BootConfigPartition
class	BootImage
class	BootImageBuilder
class	BootImageFlag
class	BootloaderEnvPartition
class	BootloaderFlag
class	BuildApi
struct	BuildApiFlags
class	BuildArchive
struct	Builds
struct	BuildStrings
class	BuildSuperImageFlag
class	CachingBuildApi
class	CallService
class	CameraController
class	CasDownloader
struct	CasDownloaderFlags
class	CasDownloaderTests
class	CasFlagsTests
struct	CasIdentifier
class	CasimirController
class	CfConnectionObserverFactory
class	CfOperatorObserver
struct	ChainPartition
class	ChannelMonitor
class	ChmapInfoCommand
struct	ChromeOsBuildArtifacts
struct	ChromeOsBuilder
class	ChromeOsStateImage
class	ChrootReadWriteFilesystem
class	Client
class	ClientFilesServer
class	ClientId
class	Command
class	CommandHandler
class	CommandParser
class	CommandRequest
class	CommandRequestBuilder
class	CommandSource
class	CompareHmacSharingParams
class	CompositeDiskImage
class	CompositeSerializable
class	CompositeSuperImageBuilder
class	CompositionManager
class	ConcatReaderSeeker
class	ConfigFlag
class	ConfigFragment
class	ConfUiSignerImpl
class	ConfUiSignRequester
class	ConfUiSignSender
class	ConfUiSignServer
class	ConnectionObserverImpl
class	ConsoleForwarder
struct	ConstructCommandParam
struct	ConstructNonHelpForm
struct	ConsumeFlagsOpts
class	ControlCommand
class	ControlInfoCommand
struct	ControlMessage
struct	ControlPanelButton
class	CpioReader
class	CpusFlag
struct	CredentialFlags
class	CredentialSource
class	CrosvmBuilder
class	CudaContext
struct	CudaFunctions
class	CurlGlobalInit
class	CustomActionConfigProvider
struct	CustomActionInstanceID
struct	CustomActionServerConfig
struct	CustomDeviceStateActionConfig
struct	CustomShellActionConfig
class	CuttlefishConfig
class	Cvd
class	CvdAbgrVideoFrameBuffer
class	Cvdalloc
class	CvdBugreportCommandHandler
class	CvdCacheCommandHandler
class	CvdClearCommandHandler
class	CvdCommandHandler
class	CvdCreateCommandHandler
class	CvdDevicePowerBtnCommandHandler
class	CvdDevicePowerwashCommandHandler
class	CvdDeviceRestartCommandHandler
class	CvdDisplayCommandHandler
class	CvdEnvCommandHandler
class	CvdFetchCommandHandler
struct	CvdFile
struct	CvdFlags
class	CvdFleetCommandHandler
class	CvdHelpHandler
class	CvdInputDevicesHandler
class	CvdLoginCommand
class	CvdLogsHandler
class	CvdMonitorCommandHandler
class	CvdPsCommandHandler
class	CvdResetCommandHandler
class	CvdSetupHandler
class	CvdSnapshotCommandHandler
class	CvdStartCommandHandler
class	CvdStatusCommandHandler
class	CvdStopCommandHandler
class	CvdVersionHandler
class	CvdVideoFrameBuffer
class	DaemonFlag
class	DataPolicyFlag
class	DataService
class	DataViewer
class	DefaultIoVisitor
class	Defaults
struct	DeviceBuild
struct	DeviceBuildString
struct	DeviceName
struct	DeviceState
class	DeviceTpm
class	DiagnosticInformation
class	DiagnosticInformationFn
struct	DiagnosticInformationFnImpl
struct	DiagnosticInformationFnImpl< Fn, R(*)(Args...)>
struct	DirectoryBuild
struct	DirectoryBuildString
class	DisjointRangeSet
class	DiskBuilder
class	DiskImage
class	DisplayHandler
class	DisplayRingBuffer
struct	DisplayRingBufferHeader
class	DisplayRingBufferManager
class	DisplaysConfigs
class	DisplaysConfigsFlag
class	DisplaysConfigsFragment
class	DisplaysProtoFlag
class	Downloaders
struct	DownloadFlags
class	DynamicFlag
class	EfiLoaderImage
class	EncryptedSerializable
class	Epoll
struct	EpollEvent
class	EspBuilder
struct	EsysDeleter
class	EsysLock
class	EventBuffer
class	EventSinkImpl
struct	ExtractCvdArgsTestParams
class	ExtraKernelCmdlineFlag
class	FactoryResetProtectedImage
class	FakeAndroidBuild
class	FakeHttpClient
class	FakeNftables
class	FastbootConfig
class	FastbootConfigFlag
class	FastbootConfigFragment
class	Fd
class	Feature
class	FetchArtifact
struct	FetchArtifacts
class	FetchBuildContext
struct	FetchCompleteMetrics
class	FetchContext
class	FetchCvdTests
class	FetcherConfig
class	FetcherConfigs
struct	FetchFailedMetrics
struct	FetchFlags
struct	FetchResult
struct	FetchStartMetrics
class	FetchTracer
class	FileMonitorSource
struct	FileSizes
class	FilesTests
class	FixedCredentialSource
class	Flag
class	FlagBase
class	FlagFeature
class	FlagForwarder
class	FlagInfo
struct	FlagMetrics
class	FlagValue
struct	FromGflags
class	FrontlineParserTestFixture
class	FuchsiaEspBuilder
class	GamepadDevice
class	GatekeeperResponder
class	GatekeeperStorage
struct	GatewayConfig
struct	GceEnvironment
class	GceMetadataCredentialSource
struct	GenericCommandImpl
struct	GenericCommandImpl< Fn, R(*)(Args...)>
class	GenericCommandSource
class	GenericReturningSetupFeature
struct	GenericSetupImpl
struct	GenericSetupImpl< Fn, Result< R >(*)(Args...)>
struct	GflagDescription
class	GnssClient
class	GpuModeFlag
struct	GroupProcInfo
class	GrpcSocketCreator
struct	GuestConfig
class	GuestEnforceSecurityFlag
struct	GuestInfo
struct	GuestMetrics
struct	Guests
class	HelpParagraph
class	HmacSerializable
struct	HostInfo
struct	HostMetrics
class	HostModeCtrl
struct	HostToolsTarget
class	HostToolTarget
class	HttpClient
struct	HttpHeader
struct	HttpRequest
struct	HttpResponse
struct	HttpVoidResponse
struct	IfaceConfig
struct	IfaceData
class	ImageFile
struct	ImagePartition
class	InfoCommand
class	InitramfsPathFlag
class	InProcessTpm
class	InputConnection
class	InputConnector
class	InputConnectorBuilder
class	InputConnectorImpl
class	InputDevice
struct	InputDevices
class	InputPathsProvider
class	InstanceBootImage
class	InstanceCompositeDisk
class	InstanceDatabase
struct	InstanceGroupParams
class	InstanceLockFile
class	InstanceLockFileManager
class	InstanceManager
class	InstanceNumsCalculator
struct	InstanceParams
class	InterruptibleTerminal
class	InterruptListenerHandle
struct	IoStatusMsg
struct	IoTransferMsg
class	IoVisitable
class	IoVisitor
struct	is_movable
class	JackInfoCommand
class	JsonSerializable
struct	KernelLine
struct	KernelLogEventsHandler
class	KernelLogPipeConsumer
class	KernelLogPipeProvider
class	KernelPathFlag
class	KeyboardDevice
class	KeymasterResponder
class	LateInjected
struct	LauncherActionInfo
struct	LauncherLine
class	LazilyLoadedFile
class	LintCommandHandler
class	LinuxEspBuilder
class	LoadConfigsCommand
struct	LoadFlags
class	LocalInstance
class	LocalInstanceGroup
class	LockFile
class	LockFileManager
struct	LogcatLine
class	LogMonitorDisplay
struct	LogMonitorDisplayResult
class	LogSink
class	LogTeeCreator
struct	LogTeeLine
class	LuciBuildApi
class	McuConfigPathFlag
class	MediaConfigs
class	MediaConfigsFlag
class	MediaConfigsFragment
class	MemoryMbFlag
class	MetadataImage
struct	MetricsData
struct	MetricsFlags
struct	MetricsInput
class	MiscImage
class	MiscService
class	ModemService
class	ModemSimulator
struct	MonitorCommand
struct	MonitorEntry
struct	MonitorOutput
class	MonitorSource
class	MouseDevice
class	Multiplexer
struct	MultitouchSlot
class	NativeFilesystem
class	NetlinkClient
class	NetlinkClientFactory
class	NetlinkRequest
class	NetworkService
class	Nftables
class	NftablesNft
class	NftRule
struct	NvencEncoderConfig
struct	NvencEncoderDeleter
class	NvencVideoEncoder
class	NvramConfig
struct	Oauth2ConsentRequest
class	OperatorControlConn
class	PackedVideoFrameBuffer
struct	Parsed
struct	ParsedFlags
class	ParseGflags
class	ParseGflagsImpl
struct	Parser
class	PDUFormatBuilder
class	PDUParser
class	PersistentVbmeta
class	PlanarVideoFrameBuffer
struct	PollSharedFd
struct	PrettyAdlPlaceholder
class	PrettyContainerType
class	PrettyStruct
class	PrimaryKeyBuilder
class	ProcessMonitor
struct	ProcInfo
struct	ProcStatusUids
class	ProxyKeymasterContext
class	ProxyServer
struct	PruneResult
class	Qcow2Image
class	RawImage
class	ReadableZip
class	ReadableZipSource
class	ReadableZipSourceCallback
class	Reader
class	ReaderFakeSeeker
class	ReaderSeeker
class	ReaderWriterSeeker
class	ReadFilesystem
class	ReadWindowView
class	ReadWriteFilesystem
class	RefreshingCredentialSource
class	RefreshTokenCredentialSource
class	RemoveCvdCommandHandler
class	RequestContext
class	RestartSubprocessesFlag
class	ReturningSetupFeature
class	RotaryDevice
class	RxBuffer
class	ScopedCudaContext
class	ScopedLogger
class	ScopedMMap
class	ScreenConnector
class	ScreenConnectorCtrl
struct	ScreenConnectorFrameInfo
struct	ScreenConnectorFrameRenderer
class	ScreenConnectorInputMultiplexer
class	ScreenConnectorQueue
class	ScreenRecordingCommandHandler
class	ScreenshotHandler
class	SeekableZipSource
class	SeekableZipSourceCallback
class	Seeker
class	SeekingZipSourceReader
class	Semaphore
struct	SemVer
struct	SensorsSocketPair
class	ServerLoop
class	ServiceAccountOauthCredentialSource
class	SetupFeature
struct	SeverityTarget
class	SharedFD
class	SharedFdIo
class	SharedFDIstream
class	SharedFDOstream
class	SharedFDSet
class	SharedFDStreambuf
class	ShmBuffer
class	SignalMasker
class	SimService
class	SmsSender
class	SmsService
class	SnapshotCommandHandler
struct	SnapshotControlFiles
class	StackTraceEntry
class	StackTraceError
class	StatusCheckCommandSource
class	StkService
struct	StopCvdParams
struct	StreamControlCommand
class	StreamInfoCommand
struct	StreamSetParamsCommand
class	Subprocess
class	SubprocessFlag
class	SubprocessOptions
class	SubprocessWaiter
class	SuperImageFlag
class	SupService
class	SwitchesDevice
class	SystemImageDirFlag
struct	TargetDirectories
class	TerminalColors
struct	TerminalSize
struct	TestData
class	TestTpm
class	ThreadLooper
class	ThreadSafeQueue
class	TouchDevice
class	TouchpadsConfigs
class	TouchpadsConfigsFlag
class	Tpm
class	TpmAttestationRecordContext
class	TpmAuth
class	TpmGatekeeper
class	TpmKeyBlobMaker
class	TpmKeymasterContext
class	TpmKeymasterEnforcement
class	TpmRandomSource
class	TpmRemoteProvisioningContext
class	TpmResourceManager
class	TpmSerializable
struct	TruncatedString
class	UnixMessageSocket
struct	UnixSocketMessage
struct	UnknownEnvironment
class	UseCvdallocFlag
struct	VbmetaArgs
struct	VectorFlags
class	VendorBootImage
class	VendorBootImageBuilder
class	VendorBootImageFlag
struct	VersionIdentifiers
class	VideoFrameBuffer
struct	VioSConfig
struct	virtio_snd_chmap_info
struct	virtio_snd_ctl_event
struct	virtio_snd_ctl_hdr
struct	virtio_snd_ctl_info
struct	virtio_snd_ctl_value
struct	virtio_snd_hdr
struct	virtio_snd_info
struct	virtio_snd_jack_info
struct	virtio_snd_pcm_hdr
struct	virtio_snd_pcm_info
struct	virtio_snd_pcm_set_params
struct	virtio_snd_pcm_status
struct	virtio_snd_pcm_xfer
struct	virtio_snd_query_info
class	VirtualModemSimulator
class	VmManagerFlag
class	VsockClientConnection
class	VsockConnection
class	VsockServerConnection
class	WaylandScreenConnector
class	WeakFD
class	WebrtcClientCommandChannel
class	WebRtcController
struct	WebRtcScProcessedFrame
class	WebrtcServerCommandChannel
class	WmediumdServer
class	WritableZip
class	WritableZipSource
class	Writer
class	WriterSeeker
struct	ZipDeleter
class	ZipSourceReader
class	ZipSourceWriter
struct	ZipStat

Typedefs
using	WalkDirectoryCallback = std::function< Result< void >(const std::string &)>
using	MiscInfo = std::map< std::string, std::string, std::less< void > >
using	PsRow = std::map< PsColumns, std::string >
using	CvdServerClock = std::chrono::system_clock
using	TimeStamp = std::chrono::time_point< CvdServerClock >
using	InterruptListener = std::function< void(int)>
using	f_func = std::function< void(const Client &)>
using	p_func = std::function< void(const Client &, std::string &)>
template<auto Fn>
using	AutoCmd = GenericCommandImpl< Fn, decltype(Fn)>
using	AutoSensorsSocketPair = AutoSetup< SensorsSocketPair::Create >
using	AutoSnapshotControlFiles = AutoSetup< SnapshotControlFiles::Create >
template<auto Fn>
using	AutoDiagnostic = DiagnosticInformationFnImpl< Fn, decltype(Fn)>
template<typename T >
using	UniqueEsysPtr = std::unique_ptr< T, EsysDeleter >
using	TpmObjectSlot = std::shared_ptr< TpmResourceManager::ObjectSlot >
using	SerializeTpmKeyPrivate = TpmSerializable< TPM2B_PRIVATE >
using	SerializeTpmKeyPublic = TpmSerializable< TPM2B_PUBLIC >
using	NvencEncoderHandle = std::unique_ptr< void, NvencEncoderDeleter >
using	OnConsumedCb = std::function< void(AudioStatus, uint32_t, uint32_t)>
using	TxBuffer = ShmBuffer
template<auto Fn>
using	AutoSetup = GenericSetupImpl< Fn, decltype(Fn)>
using	GenerateProcessedFrameCallbackImpl = std::function< void(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint8_t *)>
using	Build = std::variant< DeviceBuild, DirectoryBuild >
using	BuildString = std::variant< DeviceBuildString, DirectoryBuildString >
using	DigestsFetcher = std::function< Result< std::string >(std::string)>
using	ChromeOsBuildString = std::variant< ChromeOsBuilder, std::string >
using	ManagedZip = std::unique_ptr< zip_t, ZipDeleter >
using	ManagedZipError = std::unique_ptr< zip_error_t, ZipDeleter >
using	ManagedZipSource = std::unique_ptr< zip_source_t, ZipDeleter >
using	FetchInput = std::variant< FetchFlags, FetchResult >
using	FetchMetrics = std::variant< FetchStartMetrics, FetchCompleteMetrics, FetchFailedMetrics >
using	Environment = std::variant< GceEnvironment, GitHubRepository, UnknownEnvironment >
using	SubprocessStopper = std::function< StopperResult(Subprocess *)>
template<typename T >
using	Result = tl::expected< T, StackTraceError >

Enumerations
enum class	DeviceType {   Unknown = 0 , Phone , Wear , Auto ,   Foldable , Tv , Minidroid , Go ,   Desktop }
enum class	Arch {   Arm , Arm64 , RiscV64 , X86 ,   X86_64 }
enum class	Os { Linux , Unknown }
enum class	LogSeverity : int {   Verbose = 0 , Debug , Info , Warning ,   Error , Fatal }
enum class	MetadataLevel { FULL , ONLY_MESSAGE , TAG_AND_MESSAGE }
enum class	CoerceToNullopt { None , UnsetKeyword , EmptyString }
enum class	PsColumns {   kGroups = 0 , kNames , kId , kStatus ,   kCreated , kAdbSerial , kWebAccess }
enum class	InstanceDirActionOnStop { Keep , Clear }
enum class	InUseState : char { kInUse = 'I' , kNotInUse = 'N' }
enum	ModemSimulatorExitCodes : int { kSuccess = 0 , kSelectError = 1 , kServerError = 2 }
enum	ModemServiceType : int {   kSimService = 0 , kNetworkService = 1 , kDataService = 2 , kCallService = 3 ,   kSmsService = 4 , kSupService = 5 , kStkService = 6 , kMiscService = 7 }
enum	ModemTechnology {   M_MODEM_TECH_GSM = 1 << 0 , M_MODEM_TECH_WCDMA = 1 << 1 , M_MODEM_TECH_CDMA = 1 << 2 , M_MODEM_TECH_EVDO = 1 << 3 ,   M_MODEM_TECH_TDSCDMA = 1 << 4 , M_MODEM_TECH_LTE = 1 << 5 , M_MODEM_TECH_NR = 1 << 6 }
enum class	CvdallocStatus { kUnknown = 0 , kAvailable , kFailed }
enum	SnapshotSocketMessage : uint8_t { kSuspend = 1 , kSuspendAck = 2 , kResume = 3 }
enum class	SnapshotCmd : int { kUnknown = 0 , kSuspend = 1 , kResume = 2 , kSnapshotTake = 3 }
enum class	AudioChannelsLayout { Mono , Stereo , Surround51 }
enum class	Status : uint32_t { Ok = 0x8000 , BadMessage , NotSupported , IOError }
enum class	AudioCommandType : uint32_t {   VIRTIO_SND_R_JACK_INFO = 1 , VIRTIO_SND_R_JACK_REMAP , VIRTIO_SND_R_PCM_INFO = 0x0100 , VIRTIO_SND_R_PCM_SET_PARAMS ,   VIRTIO_SND_R_PCM_PREPARE , VIRTIO_SND_R_PCM_RELEASE , VIRTIO_SND_R_PCM_START , VIRTIO_SND_R_PCM_STOP ,   VIRTIO_SND_R_CHMAP_INFO = 0x0200 , VIRTIO_SND_R_CTL_INFO = 0x0300 , VIRTIO_SND_R_CTL_ENUM_ITEMS , VIRTIO_SND_R_CTL_READ ,   VIRTIO_SND_R_CTL_WRITE , VIRTIO_SND_R_CTL_TLV_READ , VIRTIO_SND_R_CTL_TLV_WRITE , VIRTIO_SND_R_CTL_TLV_COMMAND }
enum class	AudioStatus : uint32_t {   VIRTIO_SND_S_OK = 0x8000 , VIRTIO_SND_S_BAD_MSG , VIRTIO_SND_S_NOT_SUPP , VIRTIO_SND_S_IO_ERR ,   NOT_SET = static_cast<uint32_t>(-1) }
enum class	AudioStreamDirection : uint8_t { VIRTIO_SND_D_OUTPUT = 0 , VIRTIO_SND_D_INPUT }
enum class	AudioStreamFormat : uint8_t {   VIRTIO_SND_PCM_FMT_IMA_ADPCM = 0 , VIRTIO_SND_PCM_FMT_MU_LAW , VIRTIO_SND_PCM_FMT_A_LAW , VIRTIO_SND_PCM_FMT_S8 ,   VIRTIO_SND_PCM_FMT_U8 , VIRTIO_SND_PCM_FMT_S16 , VIRTIO_SND_PCM_FMT_U16 , VIRTIO_SND_PCM_FMT_S18_3 ,   VIRTIO_SND_PCM_FMT_U18_3 , VIRTIO_SND_PCM_FMT_S20_3 , VIRTIO_SND_PCM_FMT_U20_3 , VIRTIO_SND_PCM_FMT_S24_3 ,   VIRTIO_SND_PCM_FMT_U24_3 , VIRTIO_SND_PCM_FMT_S20 , VIRTIO_SND_PCM_FMT_U20 , VIRTIO_SND_PCM_FMT_S24 ,   VIRTIO_SND_PCM_FMT_U24 , VIRTIO_SND_PCM_FMT_S32 , VIRTIO_SND_PCM_FMT_U32 , VIRTIO_SND_PCM_FMT_FLOAT ,   VIRTIO_SND_PCM_FMT_FLOAT64 , VIRTIO_SND_PCM_FMT_DSD_U8 , VIRTIO_SND_PCM_FMT_DSD_U16 , VIRTIO_SND_PCM_FMT_DSD_U32 ,   VIRTIO_SND_PCM_FMT_IEC958_SUBFRAME }
enum	AudioStreamRate : uint8_t {   VIRTIO_SND_PCM_RATE_5512 = 0 , VIRTIO_SND_PCM_RATE_8000 , VIRTIO_SND_PCM_RATE_11025 , VIRTIO_SND_PCM_RATE_16000 ,   VIRTIO_SND_PCM_RATE_22050 , VIRTIO_SND_PCM_RATE_32000 , VIRTIO_SND_PCM_RATE_44100 , VIRTIO_SND_PCM_RATE_48000 ,   VIRTIO_SND_PCM_RATE_64000 , VIRTIO_SND_PCM_RATE_88200 , VIRTIO_SND_PCM_RATE_96000 , VIRTIO_SND_PCM_RATE_176400 ,   VIRTIO_SND_PCM_RATE_192000 , VIRTIO_SND_PCM_RATE_384000 }
enum	AudioChannelMap : uint8_t {   VIRTIO_SND_CHMAP_NONE = 0 , VIRTIO_SND_CHMAP_NA , VIRTIO_SND_CHMAP_MONO , VIRTIO_SND_CHMAP_FL ,   VIRTIO_SND_CHMAP_FR , VIRTIO_SND_CHMAP_RL , VIRTIO_SND_CHMAP_RR , VIRTIO_SND_CHMAP_FC ,   VIRTIO_SND_CHMAP_LFE , VIRTIO_SND_CHMAP_SL , VIRTIO_SND_CHMAP_SR , VIRTIO_SND_CHMAP_RC ,   VIRTIO_SND_CHMAP_FLC , VIRTIO_SND_CHMAP_FRC , VIRTIO_SND_CHMAP_RLC , VIRTIO_SND_CHMAP_RRC ,   VIRTIO_SND_CHMAP_FLW , VIRTIO_SND_CHMAP_FRW , VIRTIO_SND_CHMAP_FLH , VIRTIO_SND_CHMAP_FCH ,   VIRTIO_SND_CHMAP_FRH , VIRTIO_SND_CHMAP_TC , VIRTIO_SND_CHMAP_TFL , VIRTIO_SND_CHMAP_TFR ,   VIRTIO_SND_CHMAP_TFC , VIRTIO_SND_CHMAP_TRL , VIRTIO_SND_CHMAP_TRR , VIRTIO_SND_CHMAP_TRC ,   VIRTIO_SND_CHMAP_TFLC , VIRTIO_SND_CHMAP_TFRC , VIRTIO_SND_CHMAP_TSL , VIRTIO_SND_CHMAP_TSR ,   VIRTIO_SND_CHMAP_LLFE , VIRTIO_SND_CHMAP_RLFE , VIRTIO_SND_CHMAP_BC , VIRTIO_SND_CHMAP_BLC ,   VIRTIO_SND_CHMAP_BRC }
enum	AudioJackFeatures : uint8_t { VIRTIO_SND_JACK_F_REMAP = 0 }
enum class	AudioControlRole : uint8_t { VIRTIO_SND_CTL_ROLE_UNDEFINED = 0 , VIRTIO_SND_CTL_ROLE_VOLUME , VIRTIO_SND_CTL_ROLE_MUTE , VIRTIO_SND_CTL_ROLE_GAIN }
enum class	AudioControlType : uint8_t {   VIRTIO_SND_CTL_TYPE_BOOLEAN = 0 , VIRTIO_SND_CTL_TYPE_INTEGER , VIRTIO_SND_CTL_TYPE_INTEGER64 , VIRTIO_SND_CTL_TYPE_ENUMERATED ,   VIRTIO_SND_CTL_TYPE_BYTES , VIRTIO_SND_CTL_TYPE_IEC958 }
enum	AudioControlAccess : uint8_t {   VIRTIO_SND_CTL_ACCESS_READ = 0 , VIRTIO_SND_CTL_ACCESS_WRITE , VIRTIO_SND_CTL_ACCESS_VOLATILE , VIRTIO_SND_CTL_ACCESS_INACTIVE ,   VIRTIO_SND_CTL_ACCESS_TLV_READ , VIRTIO_SND_CTL_ACCESS_TLV_WRITE , VIRTIO_SND_CTL_ACCESS_TLV_COMMAND }
enum	RunnerExitCodes : int {   kSuccess = 0 , kArgumentParsingError = 1 , kInvalidHostConfiguration = 2 , kCuttlefishConfigurationInitError = 3 ,   kInstanceDirCreationError = 4 , kPrioFilesCleanupError = 5 , kBootImageUnpackError = 6 , kCuttlefishConfigurationSaveError = 7 ,   kDaemonizationError = 8 , kVMCreationError = 9 , kPipeIOError = 10 , kVirtualDeviceBootFailed = 11 ,   kProcessGroupError = 12 , kMonitorCreationFailed = 13 , kServerError = 2 , kUsbV1SocketError = 15 ,   kE2eTestFailed = 16 , kKernelDecompressError = 17 , kLogcatServerError = 18 , kConfigServerError = 19 ,   kTombstoneServerError = 20 , kTombstoneDirCreationError = 21 , kInitRamFsConcatError = 22 , kTapDeviceInUse = 23 ,   kTpmPassthroughError = 24 , kModemSimulatorServerError = 25 , kSocketProxyServerError = 26 }
enum class	LauncherAction : char {   kExtended = 'A' , kFail = 'F' , kPowerwash = 'P' , kRestart = 'R' ,   kStatus = 'I' , kStop = 'X' }
enum class	LauncherResponse : char { kSuccess = 'S' , kError = 'E' , kUnknownAction = 'U' }
enum class	AdbMode { VsockTunnel , VsockHalfTunnel , NativeVsock , Unknown }
enum class	APBootFlow { None , Grub , LegacyDirect }
enum class	BootFlow {   Android , AndroidEfiLoader , ChromeOs , ChromeOsDisk ,   Linux , Fuchsia }
enum class	DataImagePolicy { AlwaysCreate , ResizeUpTo , Unknown , UseExisting }
enum class	ExternalNetworkMode { kUnknown , kTap , kSlirp }
enum class	FileSource {   UNKNOWN_PURPOSE = 0 , DEFAULT_BUILD , SYSTEM_BUILD , KERNEL_BUILD ,   LOCAL_FILE , GENERATED , BOOTLOADER_BUILD , ANDROID_EFI_LOADER_BUILD ,   BOOT_BUILD , HOST_PACKAGE_BUILD , CHROME_OS_BUILD , TEST_SUITES_BUILD }
enum class	GpuMode {   Auto , Custom , DrmVirgl , Gfxstream ,   GfxstreamGuestAngle , GfxstreamGuestAngleHostLavapipe , GfxstreamGuestAngleHostSwiftshader , GuestLavapipe ,   GuestSwiftshader , None }
enum class	GuestHwuiRenderer { kUnknown , kSkiaGl , kSkiaVk }
enum class	GuestOs { Android , ChromeOs , Linux , Fuchsia }
enum class	GuestRendererPreload { kAuto , kGuestDefault , kEnabled , kDisabled }
enum class	SecureHal {   kGuestGatekeeperInsecure , kGuestKeymintInsecure , kGuestKeymintTrustyInsecure , kGuestStrongboxInsecure ,   kHostKeymintInsecure , kHostKeymintSecure , kHostGatekeeperInsecure , kHostGatekeeperSecure ,   kHostOemlockInsecure , kHostOemlockSecure , kHostWeaverSecure }
enum class	VmmMode { kUnknown , kCrosvm , kGem5 , kQemu }
enum class	GptPartitionType { kLinuxFilesystem = 0 , kEfiSystemPartition }
enum class	SafeLevel {   kSafeLevelUnspecified = 0 , kSafe0 , kSafe1 , kSafe2 ,   kPlatinum }
enum class	HttpMethod { kGet , kPost , kDelete , kHead }
enum class	ZipCompression {   kDefault , kStore , kBzip2 , kDeflate ,   kXz , kZstd }
enum class	DeviceEventType {   DeviceInstantiation , DeviceBootStart , DeviceBootComplete , DeviceStop ,   DeviceBootFailed }
enum class	GitHubRepository { AndroidCuttlefish , CloudAndroidOrchestration , Unknown }
enum class	Invoker { Acloud , HostOrchestrator , None , Unknown }
enum class	ClearcutEnvironment { Local , Staging , Production }
enum class	StopperResult { kFailure , kCrash , kSuccess }

Functions
Result< void >	AddTapIface (std::string_view name)
Result< void >	ShutdownIface (std::string_view name)
Result< void >	BringUpIface (std::string_view name)
Result< void >	AddGateway (std::string_view name, std::string_view gateway, std::string_view netmask)
Result< void >	DestroyGateway (std::string_view name, std::string_view gateway, std::string_view netmask)
Result< void >	LinkTapToBridge (std::string_view tap_name, std::string_view bridge_name)
Result< void >	DeleteIface (std::string_view name)
Result< bool >	BridgeInUse (std::string_view name)
Result< bool >	BridgeExists (std::string_view name)
Result< void >	CreateBridge (std::string_view name)
Result< void >	IptableConfig (std::string_view iptables_path, std::string_view network, bool add)
bool	CreateEthernetIface (std::string_view name, std::string_view bridge_name)
std::string	MobileGatewayName (std::string_view ipaddr, uint16_t id)
std::string	MobileNetworkName (std::string_view ipaddr, std::string_view netmask, uint16_t id)
bool	CreateMobileIface (std::string_view name, uint16_t id, std::string_view ipaddr)
bool	DestroyMobileIface (std::string_view name, uint16_t id, std::string_view ipaddr)
bool	DestroyEthernetIface (std::string_view name)
void	CleanupEthernetIface (std::string_view name)
bool	CreateTap (std::string_view name)
bool	DestroyIface (std::string_view name)
std::optional< std::string >	GetUserName (uid_t uid)
bool	DestroyBridge (std::string_view name)
bool	SetupBridgeGateway (std::string_view bridge_name, std::string_view ipaddr)
void	CleanupBridgeGateway (std::string_view name, std::string_view ipaddr, const GatewayConfig &config)
bool	StartDnsmasq (std::string_view bridge_name, std::string_view gateway, std::string_view dhcp_range)
bool	StopDnsmasq (std::string_view name)
bool	CreateEthernetBridgeIface (std::string_view name, std::string_view ipaddr)
bool	DestroyEthernetBridgeIface (std::string_view name, std::string_view ipaddr)
Result< std::string >	IptablesPath ()
Result< std::string >	DnsmasqPath ()
int	RunExternalCommand (const std::string &command)
bool	IsCsiFinalByte (char c)
std::string	AnsiCursorUp (int n)
bool	ShouldColorStdout ()
bool	ShouldColorStderr ()
Result< std::string >	RecvAll (Fd &sock, const uint64_t count)
ssize_t	WriteAll (SharedFD fd, const char *buf, size_t size)
ssize_t	ReadExact (SharedFD fd, char *buf, size_t size)
ssize_t	ReadExact (SharedFD fd, std::string *buf)
ssize_t	ReadExact (SharedFD fd, std::vector< char > *buf)
ssize_t	WriteAll (SharedFD fd, std::string_view buf)
ssize_t	WriteAll (SharedFD fd, const std::vector< char > &buf)
bool	SendAll (SharedFD sock, std::string_view msg)
template<typename T >
ssize_t	ReadExactBinary (SharedFD fd, T *binary_data)
template<typename T >
ssize_t	WriteAllBinary (SharedFD fd, const T *binary_data)
int	Select (SharedFDSet *read_set, SharedFDSet *write_set, SharedFDSet *error_set, struct timeval *timeout)
	TEST (SendFD, Basic)
Result< std::map< std::string, std::string, std::less< void > > >	ParseKeyEqualsValue (const std::string &contents)
std::string	SerializeKeyEqualsValue (const std::map< std::string, std::string > &key_equals_value)
std::string	SerializeKeyEqualsValue (const std::map< std::string, std::string, std::less< void > > &key_equals_value)
Result< void >	WriteKeyEqualsValue (const std::map< std::string, std::string > &key_equals_value, const std::string &path)
Result< void >	WriteKeyEqualsValue (const std::map< std::string, std::string, std::less< void > > &key_equals_value, const std::string &path)
Result< std::vector< std::string > >	ExtractImages (const std::string &archive_filepath, const std::string &target_directory, const std::vector< std::string > &images, const bool keep_archive)
Result< std::string >	ExtractImage (const std::string &archive_filepath, const std::string &target_directory, const std::string &image, const bool keep_archive)
Result< std::vector< std::string > >	ExtractArchiveContents (const std::string &archive_filepath, const std::string &target_directory, const bool keep_archive)
std::string	ExtractArchiveToMemory (const std::string &archive_filepath, const std::string &archive_member)
std::vector< std::string >	ArchiveContents (const std::string &archive)
Result< std::string >	EncodeBase64 (const void *data, size_t size)
Result< std::string >	EncodeBase64 (std::string_view data)
Result< std::vector< uint8_t > >	DecodeBase64 (std::string_view data)
	TEST (Base64Test, EncodeMult3)
	TEST (Base64Test, EncodeNonMult3)
	TEST (Base64Test, DecodeMult3)
	TEST (Base64Test, DecodeNonMult3)
	TEST (Base64Test, DecodeStringViewSubstring)
	TEST (Base64Test, EncodeOneZero)
	TEST (Base64Test, EncodeTwoZeroes)
	TEST (Base64Test, EncodeThreeZeroes)
	DECLARE_TYPE (Le16, uint16_t, htole16, le16toh)
	DECLARE_TYPE (Le32, uint32_t, htole32, le32toh)
	DECLARE_TYPE (Le64, uint64_t, htole64, le64toh)
	DECLARE_TYPE (Be16, uint16_t, htobe16, be16toh)
	DECLARE_TYPE (Be32, uint32_t, htobe32, be32toh)
	DECLARE_TYPE (Be64, uint64_t, htobe64, be64toh)
bool	IsRunningInContainer ()
template<typename Container , typename U , typename = std::enable_if_t< contains_internal_impl::HasFindImpl<Container, U>::value && (!contains_internal_impl::IsString<Container>::value && !contains_internal_impl::IsStringView<Container>::value), void>>
constexpr bool	Contains (Container &&container, U &&u)
template<typename T >
constexpr bool	Contains (const std::string &s, T &&t)
template<typename T >
constexpr bool	Contains (const std::string_view &s, T &&t)
DeviceType	ParseDeviceType (std::string_view type_name)
std::string_view	DeviceTypeToStringView (DeviceType device_type)
std::ostream &	operator<< (std::ostream &out, DeviceType device_type)
std::string_view	format_as (DeviceType device_type)
template<typename Sink >
void	AbslStringify (Sink &sink, DeviceType device_type)
Result< size_t >	GetDiskUsageBytes (const std::string &path)
Result< size_t >	GetDiskUsageGigabytes (const std::string &path)
std::optional< std::string >	StringFromEnv (const char *varname)
std::optional< std::string >	StringFromEnv (const std::string &varname)
std::optional< std::string >	StringFromEnv (std::string_view varname)
std::string	StringFromEnv (const char *varname, const std::string &defval)
std::string	StringFromEnv (const std::string &varname, const std::string &defval)
std::string	StringFromEnv (std::string_view varname, const std::string &defval)
	TEST (EnvironmentTest, StringFromEnvString)
	TEST (EnvironmentTest, StringFromEnvStringDefault)
	TEST (EnvironmentTest, StringFromEnvStringDefaultFallback)
	TEST (EnvironmentTest, StringFromEnvCharPtr)
	TEST (EnvironmentTest, StringFromEnvCharPtrDefault)
	TEST (EnvironmentTest, StringFromEnvCharPtrDefaultFallback)
	TEST (EnvironmentTest, StringFromEnvStringView)
	TEST (EnvironmentTest, StringFromEnvStringViewDefault)
	TEST (EnvironmentTest, StringFromEnvStringViewDefaultFallback)
Result< bool >	CanHardLink (const std::string &source, const std::string &destination)
bool	FileHasContent (const std::string &path)
Result< void >	LinkOrCopyDirectoryContentsRecursively (const std::string &source, const std::string &destination)
Result< void >	MoveDirectoryContents (const std::string &source, const std::string &destination)
Result< std::vector< std::string > >	DirectoryContentsPaths (const std::string &path)
Result< void >	EnsureDirectoryExists (const std::string &directory_path, const mode_t mode, const std::string &group_name)
Result< void >	ChangeGroup (const std::string &path, const std::string &group_name)
bool	CanAccess (const std::string &path, const int mode)
std::string	AbsolutePath (std::string_view path)
off_t	FileSize (const std::string &path)
Result< uid_t >	FileOwner (const std::string &path)
bool	MakeFileExecutable (const std::string &path)
Result< std::chrono::system_clock::time_point >	FileModificationTime (const std::string &path)
Result< std::string >	RenameFile (const std::string &current_filepath, const std::string &target_filepath)
std::string	ReadFile (const std::string &file)
Result< std::string >	ReadFileContents (const std::string &path)
Result< void >	WriteNewFile (const std::string &filepath, std::string_view content, mode_t mode)
std::string	CurrentDirectory ()
FileSizes	SparseFileSizes (const std::string &path)
Result< std::string >	FindFile (const std::string &path, const std::string &target_name)
Result< void >	WalkDirectory (const std::string &dir, const WalkDirectoryCallback &callback)
std::vector< std::string >	Path (const std::string &env_name)
Result< std::string >	Search (const std::vector< std::string > &path, std::string_view name)
Result< SharedFD >	CreateOrReuseAndDrainFifo (const std::string &path, mode_t mode)
Result< bool >	CanRename (const std::string &source, const std::string &destination)
void	CreateTempFileWithText (const std::string &filepath, const std::string &text)
	TEST_F (FilesTests, LinkOrCopyRecursivelyFailsIfSourceIsNotADirectory)
	TEST_F (FilesTests, LinkOrCopyRecursively)
	TEST_F (FilesTests, MoveDirectoryContentsFailsIfSourceIsNotADirectory)
	TEST_F (FilesTests, MoveDirectoryContents)
	TEST (FilesTest, PathWithCustomEnv)
	TEST (FilesTest, PathWithSecondCustomEnv)
	TEST (FilesTest, SearchFindsFile)
	TEST (FilesTest, SearchFileNotFoundReturnsError)
Result< void >	ValidateSetupWizardMode (const std::string &setupwizard_mode)
Result< std::vector< GflagDescription > >	ParseGflagsXmlHelp (std::string_view xml_help)
std::string_view	ArchToStringView (Arch arch)
std::ostream &	operator<< (std::ostream &out, Arch arch)
std::string_view	format_as (Arch arch)
const std::string &	HostArchStr ()
Arch	HostArch ()
HostInfo	GetHostInfo ()
bool	IsHostCompatible (Arch arch)
std::ostream &	operator<< (std::ostream &out, Os arch)
template<typename Sink >
void	AbslStringify (Sink &sink, Arch arch)
bool	InSandbox ()
std::vector< std::string >	GetCreatedFileListFromInotifyFd (int fd)
std::vector< std::string >	GetFileListFromInotifyFd (int fd, uint32_t mask)
bool	IsGoogleCorp ()
Result< Json::Value >	ParseJson (std::string_view input)
Result< Json::Value >	LoadFromFile (Reader &json_reader)
Result< Json::Value >	LoadFromFile (const std::string &path_to_file)
template<typename T >
Result< T >	As (const Json::Value &v)
template<>
Result< int >	As (const Json::Value &v)
template<>
Result< std::string >	As (const Json::Value &v)
template<>
Result< bool >	As (const Json::Value &v)
template<>
Result< Json::Value >	As (const Json::Value &v)
template<typename T >
Result< T >	GetValue (const Json::Value &root, const std::vector< std::string > &selectors)
template<typename T >
Result< std::vector< T > >	GetArrayValues (const Json::Value &array, const std::vector< std::string > &selectors)
bool	HasValue (const Json::Value &root, const std::vector< std::string > &selectors)
std::string	TempDir ()
bool	NetworkInterfaceExists (const std::string &interface_name)
std::string	MacAddressToString (const uint8_t mac[6])
std::string	Ipv6ToString (const uint8_t ip[16])
void	GenerateMobileMacForInstance (int index, uint8_t out[6])
void	GenerateEthMacForInstance (int index, uint8_t out[6])
void	GenerateWifiMacForInstance (int index, uint8_t out[6])
void	GenerateCorrespondingIpv6ForMac (const uint8_t mac[6], uint8_t out[16])
std::string	GenerateRandomString (const std::string &alphabet, const int length)
Result< SemVer >	ParseSemVer (std::string_view str)
	TEST (SemVer, ParseBasic)
	TEST (SemVer, ParseWithPrereleaseAndMetadata)
	TEST (SemVer, ParseInvalid)
void	ChangeSignalHandlers (void(*handler)(int), std::vector< int > signals)
constexpr uint64_t	AlignToPowerOf2 (uint64_t val, uint8_t align_log)
void	Proxy (SharedFD server, std::function< SharedFD()> conn_factory)
std::unique_ptr< ProxyServer >	ProxyAsync (SharedFD server, std::function< SharedFD()> conn_factory)
std::string	StripColorCodes (const std::string &str)
std::string	FromSeverity (LogSeverity severity)
Result< LogSeverity >	ToSeverity (std::string_view value)
static LogSeverity	GuessSeverity (const std::string &env_var, LogSeverity default_value)
LogSeverity	ConsoleSeverity ()
LogSeverity	LogFileSeverity ()
void	SetLoggers (std::vector< SeverityTarget > destinations, const std::string &log_prefix)
void	LogToStderr (const std::string &log_prefix, MetadataLevel metadata_level, std::optional< LogSeverity > severity)
void	LogToFiles (const std::vector< std::string > &files, const std::string &log_prefix)
void	LogToStderrAndFiles (const std::vector< std::string > &files, const std::string &log_prefix, MetadataLevel stderr_level, std::optional< LogSeverity > stderr_severity)
template<typename T >
constexpr std::string_view	TypeName ()
template<auto T>
constexpr std::string_view	ValueName ()
SharedFD	CreateMemFDWithData (const std::string &data)
std::string	ReadAllFDData (SharedFD fd)
	TEST (UnixSocketMessage, ExtractFileDescriptors)
std::pair< UnixMessageSocket, UnixMessageSocket >	UnixMessageSocketPair ()
	TEST (UnixMessageSocket, SendPlainMessage)
	TEST (UnixMessageSocket, SendFileDescriptor)
	TEST (UnixMessageSocket, SendTwoFileDescriptors)
	TEST (UnixMessageSocket, SendCredentials)
	TEST (UnixMessageSocket, BadCredentialsBlocked)
	TEST (UnixMessageSocket, AutoCredentials)
gid_t	GroupIdFromName (const std::string &group_name)
bool	InGroup (const std::string &group)
Result< std::string >	SystemWideUserHome ()
Result< std::string >	CurrentUserName ()
bool	IsKvmAccessible ()
std::string	GenerateUuid ()
Result< void >	WaitForUnixSocket (const std::string &path, int timeoutSec)
Result< void >	WaitForUnixSocketListeningWithoutConnect (const std::string &path, int timeoutSec)
Result< bool >	AreHardLinked (const std::string &source, const std::string &destination)
Result< void >	Copy (std::string_view from, std::string_view to)
Result< void >	CopyWithAttributes (const std::string &from, const std::string &to)
Result< std::vector< std::string > >	DirectoryContents (const std::string &path)
bool	DirectoryExists (const std::string &path, bool follow_symlinks)
Result< dev_t >	FileDeviceId (const std::string &path)
bool	FileExists (const std::string &path, bool follow_symlinks)
bool	FileIsSocket (const std::string &path)
Result< bool >	IsDirectoryEmpty (const std::string &path)
Result< bool >	IsSymlink (const std::string &path)
Result< std::string >	LinkOrCopy (const std::string &target, const std::string &destination, const bool overwrite_existing)
Result< void >	RecursivelyRemoveDirectory (const std::string &path)
std::ostream &	operator<< (std::ostream &out, const Flag &flag)
Result< void >	ConsumeFlags (const std::vector< Flag > &flags, std::vector< std::string > &args, ConsumeFlagsOpts opts)
Result< void >	ConsumeFlags (const std::vector< Flag > &flags, std::vector< std::string > &&args, ConsumeFlagsOpts opts)
	TEST (FlagParser, DuplicateAlias)
	TEST (FlagParser, RepeatedListFlag)
	TEST (FlagParser, UnexpectedArgumentGuard)
	TEST (FlagParser, EndOfOptionMark)
	TEST (FlagParser, ValueNameHint_Customized)
	TEST (FlagParser, ValueNameHint_CustomizedWithAlias)
	TEST (FlagParser, ValueNameHint_DefaultDerived)
	TEST (FlagParser, ValueNameHint_DefaultDerivedDashed)
	TEST (FlagParser, ValueNameHint_DefaultDerivedSnaked)
void	WriteGflagsCompatXml (const Flag &flag, std::ostream &out)
void	WriteGflagsCompatXml (const std::vector< Flag > &flags, std::ostream &out)
Flag	HelpFlag (const std::vector< Flag > &flags, std::string text)
Flag	HelpXmlFlag (const std::vector< Flag > &flags, std::ostream &out, bool &print_xml, std::string text)
Flag	GflagsCompatFlag (const std::string &name, std::string &value)
Flag	GflagsCompatFlag (const std::string &name, int32_t &value)
Flag	GflagsCompatFlag (const std::string &name, size_t &value)
Flag	GflagsCompatFlag (const std::string &name, bool &value)
Flag	GflagsCompatFlag (const std::string &name, std::vector< std::string > &value)
Flag	GflagsCompatFlag (const std::string &name, std::vector< unsigned > &value)
Flag	GflagsCompatFlag (const std::string &name, std::vector< bool > &value, const bool default_value)
Flag	GflagsCompatFlag (const std::string &name, std::optional< std::string > &value, CoerceToNullopt opt)
Flag	GflagsCompatFlag (const std::string &name, std::optional< int > &value, CoerceToNullopt opt)
Flag	GflagsCompatFlag (const std::string &name, std::optional< size_t > &value, CoerceToNullopt opt)
Flag	GflagsCompatFlag (const std::string &name, std::optional< unsigned > &value, CoerceToNullopt opt)
Flag	GflagsCompatFlag (const std::string &name, std::optional< int64_t > &value, CoerceToNullopt opt)
Flag	GflagsCompatFlag (const std::string &name, std::optional< bool > &value, CoerceToNullopt opt)
Flag	GflagsCompatFlag (const std::string &name, std::optional< std::vector< std::string > > &value, CoerceToNullopt opt)
Flag	GflagsCompatFlag (const std::string &name, std::optional< std::vector< unsigned > > &value, CoerceToNullopt opt)
	TEST (FlagParser, StringFlag)
	TEST (FlagParser, NormalizedStringFlag)
std::optional< std::map< std::string, std::string > >	flagXml (const Flag &f)
	TEST (FlagParser, StringFlagXml)
	TEST (FlagParser, RepeatedStringFlag)
	TEST (FlagParser, FlagRemoval)
	TEST (FlagParser, IntFlag)
	TEST (FlagParser, IntFlagXml)
	TEST (FlagParser, BoolFlag)
	TEST (FlagParser, BoolFlagXml)
	TEST (FlagParser, StringIntFlag)
	TEST (FlagParser, StringVectorFlag)
	TEST (FlagParser, BoolVectorFlag)
	TEST (FlagParser, InvalidStringFlag)
	TEST (FlagParser, InvalidIntFlag)
	TEST (FlagParser, OptionalStringFlag_DefaultOptNotPresent)
	TEST (FlagParser, OptionalStringFlag_DefaultOptPresent)
	TEST (FlagParser, OptionalStringFlag_DefaultOptEmtpyFlag)
	TEST (FlagParser, OptionalStringFlag_EmptyOptEmtpyFlag)
	TEST (FlagParser, OptionalStringFlag_EmptyOptPresent)
	TEST (FlagParser, OptionalStringFlag_UnsetOptUnsetValue)
	TEST (FlagParser, OptionalStringFlag_UnsetOptOtherValue)
	TEST (FlagParser, OptionalStringVectorFlag_DefaultOptNotPresent)
	TEST (FlagParser, OptionalStringVectorFlag_DefaultOptPresent)
	TEST (FlagParser, OptionalStringVectorFlag_DefaultOptEmptyValue)
	TEST (FlagParser, OptionalStringVectorFlag_EmptyOptEmptyValue)
	TEST (FlagParser, OptionalStringVectorFlag_EmptyOptPresent)
	TEST (FlagParser, OptionalStringVectorFlag_UnsetOptUnsetValue)
	TEST (FlagParser, OptionalStringVectorFlag_UnsetOptPresent)
	TEST (FlagParser, OptionalBoolFlag_DefaultOptNotPresent)
	TEST (FlagParser, OptionalBoolFlag_DefaultOptPresent_FlagOnly)
	TEST (FlagParser, OptionalBoolFlag_DefaultOptPresent_TrueValue)
	TEST (FlagParser, OptionalBoolFlag_DefaultOptPresent_FalseValue)
	TEST (FlagParser, OptionalBoolFlag_NoFlag)
	TEST (FlagParser, OptionalBoolFlag_EmptyOptEmptyFlag)
	TEST (FlagParser, OptionalBoolFlag_UnsetOptUnsetValue)
	TEST (FlagParser, OptionalInt64Flag_Present)
	TEST (FlagParser, OptionalInt64Flag_NotPresent)
	TEST (FlagParser, VectorFlagValueNameHint_StringVector)
	TEST (FlagParser, VectorFlagValueNameHint_UnsignedVector)
	TEST (FlagParser, VectorFlagValueNameHint_BoolVector)
	TEST (FlagParser, VectorFlagValueNameHint_OptionalStringVector)
	TEST (FlagParser, VectorFlagValueNameHint_OptionalUnsignedVector)
Flag	SharedFDFlag (const std::string &name, SharedFD &out)
static Result< std::string >	InterfaceName (const CuttlefishConfig::InstanceSpecific &instance, const std::string &name)
Result< IfaceConfig >	DefaultNetworkInterfaces (const CuttlefishConfig::InstanceSpecific &instance)
std::optional< IfaceConfig >	AllocateNetworkInterfaces ()
std::ostream &	operator<< (std::ostream &out, const AndroidBuild &build)
std::string	format_as (const AndroidBuild &build)
PrettyStruct	Pretty (AndroidBuild &build, PrettyAdlPlaceholder)
std::ostream &	operator<< (std::ostream &out, const AndroidBuilds &builds)
std::string	format_as (const AndroidBuilds &builds)
PrettyStruct	Pretty (AndroidBuilds &builds, PrettyAdlPlaceholder)
Result< std::unique_ptr< AndroidBuild > >	AndroidDistBuild (const std::string &product_dir)
Result< std::unique_ptr< AndroidBuild > >	AndroidProductDir (std::string path)
Result< std::unique_ptr< AndroidBuild > >	CombinedAndroidBuild (std::string name, std::vector< std::unique_ptr< AndroidBuild > > builds)
std::string_view	ImageStatusToStringView (FakeAndroidBuild::ImageStatus image_status)
template<typename Sink >
void	AbslStringify (Sink &sink, FakeAndroidBuild::ImageStatus image_status)
Result< std::unique_ptr< AndroidBuild > >	FetchedAndroidBuild (const FetcherConfig &config, FileSource source)
Result< BuildArchive >	FindBuildArchive (const FetcherConfig &config, FileSource source, std::string_view pattern)
Result< BuildArchive >	FindBuildArchive (const std::string &directory_path, std::string_view pattern)
Result< std::unique_ptr< AndroidBuild > >	IdentifyAndroidBuild (const std::string &system_image_dir, const FetcherConfig &config, FileSource source)
Result< std::unique_ptr< AndroidBuild > >	IdentifyAndroidBuild (const AndroidBuildKey &android_build_key)
std::string	format_as (const AndroidBuildKey &key)
std::ostream &	operator<< (std::ostream &out, const AndroidBuildKey &key)
PrettyStruct	Pretty (const AndroidBuildKey &key, PrettyAdlPlaceholder)
Result< std::unique_ptr< AndroidBuild > >	ImgZip (const FetcherConfig &config, FileSource source)
Result< std::unique_ptr< AndroidBuild > >	ImgZip (const std::string &path)
Result< std::unique_ptr< AndroidBuild > >	AndroidBuildFromMiscInfo (std::map< std::string, std::string, std::less< void > > misc_info)
Result< std::unique_ptr< AndroidBuild > >	PhysicalPartitions (AndroidBuild &build)
Result< std::unique_ptr< AndroidBuild > >	SuperImageAsBuild (AndroidBuild &build)
Result< std::unique_ptr< AndroidBuild > >	TargetFiles (const FetcherConfig &config, FileSource source)
Result< std::unique_ptr< AndroidBuild > >	TargetFiles (const std::string &path)
Result< int >	AssembleCvdMain (int argc, char **argv)
static std::string	KernelCommandLineImpl (const boot_img_hdr_v0 &v0)
static std::string	KernelCommandLineImpl (const boot_img_hdr_v3 &v3)
static uint32_t	PageSizeImpl (const boot_img_hdr_v0 &v0)
static uint32_t	PageSizeImpl (const boot_img_hdr_v3 &)
static uint32_t	KernelSize (const boot_img_hdr_v0 &v0)
static uint32_t	KernelSize (const boot_img_hdr_v3 &v3)
static uint32_t	RamdiskSize (const boot_img_hdr_v0 &v0)
static uint32_t	RamdiskSize (const boot_img_hdr_v3 &v3)
static uint32_t	OsVersionImpl (const boot_img_hdr_v0 &v0)
static uint32_t	OsVersionImpl (const boot_img_hdr_v3 &v3)
static std::unique_ptr< ReaderSeeker >	PagePadding (uint64_t size)
static std::unique_ptr< ReaderSeeker >	PagePadding (uint64_t size, uint64_t page_size)
Result< void >	PackRamdisk (const std::string &ramdisk_stage_dir, const std::string &output_ramdisk)
Result< void >	UnpackRamdisk (const std::string &original_ramdisk_path, const std::string &ramdisk_stage_dir)
Result< void >	UnpackBootImage (const std::string &boot_image_path, const std::string &unpack_dir)
Result< VendorBootImage >	UnpackVendorBootImageIfNotUnpacked (const std::string &vendor_boot_image_path, const std::string &unpack_dir)
Result< void >	RepackBootImage (const std::string &new_kernel_path, const std::string &boot_image_path, const std::string &new_boot_image_path)
Result< void >	RepackVendorBootImage (const std::string &new_ramdisk, const std::string &vendor_boot_image_path, const std::string &new_vendor_boot_image_path, const std::string &unpack_dir, bool bootconfig_supported)
Result< void >	RepackVendorBootImageWithEmptyRamdisk (const std::string &vendor_boot_image_path, const std::string &new_vendor_boot_image_path, const std::string &unpack_dir, bool bootconfig_supported)
Result< void >	RepackGem5BootImage (const std::string &initrd_path, const std::optional< BootConfigPartition > &bootconfig_partition, const std::string &unpack_dir, const std::string &input_ramdisk_path)
Result< std::string >	ReadAndroidVersionFromBootImage (const std::string &boot_image_path)
Result< void >	ValidateBoardBootconfigKeys (const cuttlefish::DeviceType type, const std::map< std::string, std::string, std::less< void > > args)
Result< std::unordered_map< std::string, std::string > >	BootconfigArgsFromConfig (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance, const std::map< std::string, std::string, std::less< void > > builtin_bootconfig_args)
Result< std::string >	BootconfigArgsString (const std::unordered_map< std::string, std::string > &args, const std::string &separator)
Result< void >	CleanPriorFiles (const std::set< std::string > &preserving, const std::vector< std::string > &clean_dirs)
Result< void >	CreateDynamicDiskFiles (const FetcherConfigs &fetcher_configs, const CuttlefishConfig &config, AndroidBuilds &android_builds, const BootImageFlag &boot_image, const SystemImageDirFlag &system_image_dirs)
Result< void >	InitializeAccessKregistryImage (const CuttlefishConfig::InstanceSpecific &instance)
Result< std::vector< ImagePartition > >	AndroidCompositeDiskConfig (const CuttlefishConfig::InstanceSpecific &instance, const std::vector< std::unique_ptr< ImageFile > > &image_files, AndroidBuild &android_build, const SystemImageDirFlag &system_image_dir)
DiskBuilder	ApCompositeDiskBuilder (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance)
Result< void >	BootloaderPresentCheck (const CuttlefishConfig::InstanceSpecific &instance)
std::vector< ImagePartition >	ChromeOsCompositeDiskConfig (const CuttlefishConfig::InstanceSpecific &instance, const ChromeOsStateImage &chrome_os_state)
std::vector< ImagePartition >	FuchsiaCompositeDiskConfig (const CuttlefishConfig::InstanceSpecific &instance)
Result< void >	Gem5ImageUnpacker (const CuttlefishConfig &config, const BootImageFlag &boot_image)
Result< void >	InitializeHwcomposerPmemImage (const CuttlefishConfig::InstanceSpecific &instance)
Result< void >	RepackKernelRamdisk (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance)
std::vector< ImagePartition >	LinuxCompositeDiskConfig (const CuttlefishConfig::InstanceSpecific &instance)
Result< DiskBuilder >	OsCompositeDiskBuilder (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance, const std::optional< ChromeOsStateImage > &chrome_os_state, const std::vector< std::unique_ptr< ImageFile > > &image_files, AndroidBuild &android_build, const SystemImageDirFlag &system_image_dir)
Result< void >	InitializePflash (const CuttlefishConfig::InstanceSpecific &instance)
Result< void >	InitializePstore (const CuttlefishConfig::InstanceSpecific &instance)
Result< void >	InitializeSdCard (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance)
Result< void >	VbmetaEnforceMinimumSize (const CuttlefishConfig::InstanceSpecific &instance)
static std::chrono::system_clock::time_point	LastUpdatedInputDisk (const std::vector< ImagePartition > &partitions)
Result< void >	DiskImageFlagsVectorization (CuttlefishConfig &config, const FetcherConfigs &fetcher_configs, const AndroidEfiLoaderFlag &android_efi_loader, const BootImageFlag &boot_image, const BootloaderFlag &bootloader, const InitramfsPathFlag &initramfs_path, const KernelPathFlag &kernel_path, const SuperImageFlag &super_image, const SystemImageDirFlag &system_image_dir, const VendorBootImageFlag &vendor_boot_image)
fruit::Component< DisplaysConfigs >	DisplaysConfigsComponent ()
fruit::Component< fruit::Required< DisplaysConfigs, ConfigFlag >, DisplaysConfigsFlag >	DisplaysConfigsFlagComponent ()
fruit::Component< fruit::Required< DisplaysConfigs >, DisplaysConfigsFragment >	DisplaysConfigsFragmentComponent ()
static std::string	XmlEscape (const std::string &s)
fruit::Component< fruit::Required< ConfigFlag >, ParseGflags >	GflagsComponent ()
Result< CuttlefishConfig >	InitializeCuttlefishConfiguration (const std::string &root_dir, const std::vector< GuestConfig > &guest_configs, fruit::Injector<> &injector, const FetcherConfigs &fetcher_configs, const BootImageFlag &boot_image, const InitramfsPathFlag &initramfs_path, const KernelPathFlag &kernel_path, const SuperImageFlag &super_image, const SystemImageDirFlag &system_image_dir, const VendorBootImageFlag &vendor_boot_image, const VmManagerFlag &vm_manager_flag, const Defaults &defaults)
Result< void >	SetDefaultFlagsForCrosvm (const SystemImageDirFlag &system_image_dir, const std::vector< GuestConfig > &guest_configs, std::map< std::string, std::string > &name_to_default_value)
void	SetDefaultFlagsForGem5 ()
void	SetDefaultFlagsForOpenwrt (Arch target_arch)
Result< void >	SetFlagDefaultsForVmm (const std::vector< GuestConfig > &guest_configs, const SystemImageDirFlag &system_image_dir, const VmManagerFlag &vm_manager_flag)
Result< Defaults >	GetFlagDefaultsFromConfig ()
std::string	GetConfigFilePath (const CuttlefishConfig &config)
Result< FromGflags< bool > >	BoolFromGlobalGflags (const gflags::CommandLineFlagInfo &flag_info, const std::string &flag_name)
Result< FromGflags< bool > >	BoolFromGlobalGflags (const gflags::CommandLineFlagInfo &flag_info, const std::string &flag_name, bool default_value)
Result< FromGflags< int > >	IntFromGlobalGflags (const gflags::CommandLineFlagInfo &flag_info, const std::string &flag_name)
Result< FromGflags< std::string > >	StringFromGlobalGflags (const gflags::CommandLineFlagInfo &flag_info, const std::string &flag_name)
Result< bool >	ParseBool (std::string_view value, std::string_view name)
Result< int >	ParseInt (const std::string &value, std::string_view name)
bool	VmManagerIsCrosvm (const VmManagerFlag &vmm)
bool	VmManagerIsQemu (const VmManagerFlag &vmm)
bool	VmManagerIsGem5 (const VmManagerFlag &vmm)
gfxstream::proto::GraphicsAvailability	GetGraphicsAvailabilityWithSubprocessCheck ()
Result< GpuMode >	ConfigureGpuSettings (const gfxstream::proto::GraphicsAvailability &graphics_availability, GpuMode gpu_mode_arg, const std::string &gpu_vhost_user_mode_arg, const std::string &gpu_renderer_features_arg, std::string &gpu_context_types_arg, const std::string &guest_hwui_renderer_arg, const std::string &guest_renderer_preload_arg, VmmMode vmm, const GuestConfig &guest_config, CuttlefishConfig::MutableInstanceSpecific &instance)
PrettyStruct	Pretty (const GuestConfig &config, PrettyAdlPlaceholder)
Result< std::vector< GuestConfig > >	ReadGuestConfig (const BootImageFlag &boot_image, const KernelPathFlag &kernel_path, const SystemImageDirFlag &system_image_dirs)
std::vector< std::vector< std::unique_ptr< ImageFile > > >	InstanceImageFiles (const CuttlefishConfig &config, const BootImageFlag &boot_image_flag)
Result< bool >	IsKernelModuleSigned (ReaderSeeker &file)
fruit::Component< MediaConfigs >	MediaConfigsComponent ()
fruit::Component< fruit::Required< MediaConfigs, ConfigFlag >, MediaConfigsFlag >	MediaConfigsFlagComponent ()
fruit::Component< fruit::Required< MediaConfigs >, MediaConfigsFragment >	MediaConfigsFragmentComponent ()
Result< MiscInfo >	GetCombinedDynamicPartitions (const MiscInfo &vendor_info, const MiscInfo &system_info, const std::set< std::string > &extracted_images)
Result< MiscInfo >	MergeMiscInfos (const MiscInfo &vendor_info, const MiscInfo &system_info, const MiscInfo &combined_dp_info, const std::vector< std::string > &system_partitions)
Result< VbmetaArgs >	GetVbmetaArgs (const MiscInfo &misc_info, const std::string &image_path)
Result< void >	ConfigureNetworkSettings (const std::string &ril_dns_arg, const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &const_instance, CuttlefishConfig::MutableInstanceSpecific &instance)
std::vector< std::string >	RequiredDirectories (const CuttlefishConfig &config)
Result< void >	ResolveInstanceFiles (const BootImageFlag &boot_image, const InitramfsPathFlag &initramfs_path, const KernelPathFlag &kernel_path, const SuperImageFlag &super_image, const SystemImageDirFlag &system_image_dir, const VendorBootImageFlag &vendor_boot_image)
Result< void >	RebuildSuperImageIfNecessary (const FetcherConfig &fetcher_config, const CuttlefishConfig::InstanceSpecific &instance)
Result< bool >	SuperImageNeedsRebuilding (const FetcherConfig &fetcher_config, const std::string &default_target_zip, const std::string &system_target_zip)
fruit::Component< TouchpadsConfigs >	TouchpadsConfigsComponent ()
fruit::Component< fruit::Required< TouchpadsConfigs, ConfigFlag >, TouchpadsConfigsFlag >	TouchpadsConfigsFlagComponent ()
	TEST (DisplayConfigTest, ParseProto)
Result< void >	BuildDlkmImage (const std::string &src_dir, const bool is_erofs, const std::string &partition_name, const std::string &output_image)
Result< void >	RepackSuperWithPartition (const std::string &superimg_path, const std::string &image_path, const std::string &partition_name)
Result< void >	BuildVbmetaImage (const std::string &vendor_dlkm_img, const std::string &vbmeta_path)
Result< void >	SplitRamdiskModules (const std::string &ramdisk_path, const std::string &ramdisk_stage_dir, const std::string &vendor_dlkm_build_dir, const std::string &system_dlkm_build_dir)
bool	FileEquals (const std::string &file1, const std::string &file2)
bool	MoveIfChanged (const std::string &src, const std::string &dst)
Result< std::vector< uint8_t > >	WithCrc16A (const std::vector< uint8_t > &data)
Result< std::vector< uint8_t > >	WithCrc16B (const std::vector< uint8_t > &data)
Result< std::vector< uint8_t > >	HexToBytes (const std::string &hex_string)
int	ConsoleForwarderMain (int argc, char **argv)
Result< void >	EmptyCache (const std::string &cache_directory)
Result< size_t >	GetCacheSize (const std::string &cache_directory)
Result< PruneResult >	PruneCache (const std::string &cache_directory, const size_t allowed_size_gb)
Result< bool >	HasHelpFlag (const std::vector< std::string > &args)
std::unique_ptr< CvdCommandHandler >	NewCvdMonitorCommandHandler (InstanceManager &instance_manager)
Result< uint32_t >	DrainInotifyEvents (SharedFD inotify_fd)
Result< KernelLine >	ParseKernelLine (std::string_view line)
std::string	FormatKernelLine (const KernelLine &line)
Result< std::string >	ColorKernelLine (std::string_view line)
	TEST (KernelTest, ParseKernelLineValid)
	TEST (KernelTest, ParseKernelLineNoColon)
	TEST (KernelTest, ParseKernelLineParens)
	TEST (KernelTest, ParseKernelLineInvalid)
Result< LauncherLine >	ParseLauncherLine (std::string_view line)
std::string	FormatLauncherLine (const LauncherLine &line)
Result< std::string >	ColorLauncherLine (std::string_view line)
Result< bool >	FilterLauncherLine (LogSeverity filter, std::string_view line)
	TEST (LauncherTest, ParseLauncherLineValid)
	TEST (LauncherTest, ParseLauncherLineInvalid)
std::unique_ptr< MonitorSource >	LauncherLogMonitorSource (const LocalInstance &instance, const LogSeverity severity)
std::unique_ptr< MonitorSource >	KernelLogMonitorSource (const LocalInstance &instance)
std::unique_ptr< MonitorSource >	LogcatMonitorSource (const LocalInstance &instance, const LogSeverity severity)
Result< LogTeeLine >	ParseLogTeeLine (std::string_view line)
std::string	FormatLogTeeLine (const LogTeeLine &line)
Result< std::string >	ColorLogTeeLine (std::string_view line)
Result< bool >	FilterLogTeeLine (LogSeverity filter, std::string_view line)
	TEST (LogTeeTest, ParseLogTeeLineValid)
	TEST (LogTeeTest, ParseLogTeeLineInvalid)
Result< LogcatLine >	ParseLogcatLine (std::string_view line)
std::string	FormatLogcatLine (const LogcatLine &line)
Result< std::string >	ColorLogcatLine (std::string_view line)
Result< bool >	FilterLogcatLine (LogSeverity filter, std::string_view line)
	TEST (LogcatTest, ParseLogcatLineValid)
	TEST (LogcatTest, ParseLogcatLineInvalid)
Result< void >	MonitorLogs (const LocalInstance &instance, SharedFD stop_eventfd, LogSeverity severity)
Result< LogSeverity >	CharToLogSeverity (char severity)
std::string_view	GetColorForSeverity (LogSeverity severity)
bool	FilterSeverity (LogSeverity filter_severity, LogSeverity test_severity)
TruncatedString	TruncateColoredString (std::string_view s, size_t max_visible_width)
	TEST (TruncateColoredStringTest, NoAnsiNoTruncate)
	TEST (TruncateColoredStringTest, NoAnsiTruncate)
	TEST (TruncateColoredStringTest, AnsiNoTruncate)
	TEST (TruncateColoredStringTest, AnsiTruncate)
	TEST (TruncateColoredStringTest, AnsiTruncateNoResetInInput)
std::string	FormatByteSize (uint64_t size)
Result< selector::SelectorOptions >	ExtractCvdArgs (std::vector< std::string > &args)
	TEST_P (FrontlineParserTestFixture, FrontlineParserTest)
	INSTANTIATE_TEST_SUITE_P (SelectNoArgs, FrontlineParserTestFixture, ::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "subcmd"},.expected_args={"cvd", "subcmd"},.expected_options=selector::SelectorOptions{ .group_name=std::nullopt,.instance_names=std::nullopt}}))
	INSTANTIATE_TEST_SUITE_P (SelectNoSubCmdNoSelectors, FrontlineParserTestFixture, ::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd"},.expected_args={"cvd"},.expected_options=selector::SelectorOptions{ .group_name=std::nullopt,.instance_names=std::nullopt}}))
	INSTANTIATE_TEST_SUITE_P (SelectNoSubCmd, FrontlineParserTestFixture, ::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "--group_name=group", "--instance_name=1"},.expected_args={"cvd"},.expected_options=selector::SelectorOptions{ .group_name="group",.instance_names=std::vector< std::string >{"1"}}}))
	INSTANTIATE_TEST_SUITE_P (SelectNoSelectors, FrontlineParserTestFixture, ::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "subcmd", "arg1", "arg2"},.expected_args={"cvd", "subcmd", "arg1", "arg2"},.expected_options=selector::SelectorOptions{ .group_name=std::nullopt,.instance_names=std::nullopt}}))
	INSTANTIATE_TEST_SUITE_P (SelectGroup, FrontlineParserTestFixture, ::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "--group_name=group", "subcmd", "arg1", "arg2"},.expected_args={"cvd", "subcmd", "arg1", "arg2"},.expected_options=selector::SelectorOptions{ .group_name="group",.instance_names=std::nullopt}}))
	INSTANTIATE_TEST_SUITE_P (SelectOneInstance, FrontlineParserTestFixture, ::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "--instance_name=1", "subcmd", "arg1", "arg2"},.expected_args={"cvd", "subcmd", "arg1", "arg2"},.expected_options=selector::SelectorOptions{ .group_name=std::nullopt,.instance_names=std::vector< std::string >{"1"}}}))
	INSTANTIATE_TEST_SUITE_P (SelectGroupAndInstances, FrontlineParserTestFixture, ::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "--instance_name=a,b,c", "-group_name=group", "subcmd", "arg1", "arg2"},.expected_args={"cvd", "subcmd", "arg1", "arg2"},.expected_options=selector::SelectorOptions{ .group_name="group",.instance_names=std::vector< std::string >{ "a", "b", "c", }}}))
	INSTANTIATE_TEST_SUITE_P (SelectWithEmptyInstanceNames, FrontlineParserTestFixture, ::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "--instance_name=a,,", "-group_name=group", "subcmd", "arg1", "arg2"},.expected_args={"cvd", "subcmd", "arg1", "arg2"},.expected_options=selector::SelectorOptions{ .group_name="group",.instance_names=std::vector< std::string >{ "a", "", "", }}}))
std::string	FormatHelpText (const std::vector< HelpParagraph > &text, size_t max_line_width)
std::string	FormatFlagsHelp (const std::vector< Flag > &flags, size_t max_line_width)
std::string	CvdUserLogDir ()
std::string	GetCvdLogFileName (const std::string &log_dir, const std::chrono::system_clock::time_point now)
Result< void >	PruneLogsDirectory (const std::string &log_dir, size_t retain)
std::vector< std::string >	MergeResults (std::vector< std::string > first_list, std::vector< std::string > scond_list)
void	MergeTwoJsonObjs (Json::Value &dst, const Json::Value &src)
	This function merges two json objects and override json tree in dst with src json keys. More...
template<typename T >
std::string	GenerateFlag (const std::string &name, const T &value)
template<typename T >
std::string	GenerateVecFlag (const std::string &name, const T &collection)
template<typename T >
std::string	GenerateInstanceFlag (const std::string &name, const cvd::config::EnvironmentSpecification &config, T callback)
template<typename T >
Result< std::string >	ResultInstanceFlag (const std::string &name, const cvd::config::EnvironmentSpecification &config, T callback)
Result< std::vector< std::string > >	GenerateInstancesFlags (const EnvironmentSpecification &cfg)
Result< std::vector< std::string > >	GenerateInstancesFlags (const cvd::config::EnvironmentSpecification &cfg)
Result< EnvironmentSpecification >	ValidateCfConfigs (const Json::Value &root)
	TEST (FlagsInheritanceTest, MergeTwoIndependentJson)
	TEST (FlagsInheritanceTest, MergeTwoOverlappedJson)
Result< std::vector< std::string > >	ParseFetchCvdConfigs (const EnvironmentSpecification &config, const std::string &target_directory, const std::vector< std::string > &target_subdirectories)
Result< std::vector< std::string > >	ParseFetchCvdConfigs (const cvd::config::EnvironmentSpecification &, const std::string &target_directory, const std::vector< std::string > &target_subdirectories)
	TEST (FetchConfigParserTests, AndroidEfiLoaderBuildOnlySuccess)
	TEST (FetchConfigParserTests, KernelBuildOnlySuccess)
	TEST (FetchConfigParserTests, NoBuildStringsProducesNoFlagsSuccess)
	TEST (FlagsParserTest, ParseInvalidJson)
	TEST (FlagsParserTest, ParseJsonWithSpellingError)
	TEST (FlagsParserTest, ParseBasicJsonSingleInstances)
	TEST (FlagsParserTest, ParseBasicJsonTwoInstances)
	TEST (BootFlagsParserTest, ParseNetSimFlagEmptyJson)
	TEST (BootFlagsParserTest, ParseNetSimFlagEnabled)
	TEST (BootFlagsParserTest, ParseNetSimArgs)
	TEST (BootFlagsParserTest, ParseNetSimArgsWhitespaceError)
	TEST (CvdLoadFlagsTest, CredentialSourceSetter)
	TEST (CvdLoadFlagsTest, CredentialSourceGetter)
	TEST (CvdLoadFlagsTest, CredentialSourceDuplicated)
	TEST (CvdLoadFlagsTest, ProjectIDSetter)
	TEST (CvdLoadFlagsTest, ProjectIDGetter)
	TEST (CvdLoadFlagsTest, ProjectIDDuplicated)
	TEST (CvdLoadFlagsTest, CredentialSourceConflictWithOverride)
	TEST (CvdLoadFlagsTest, OverrideConflictWithCredentialSource)
	TEST (CvdLoadFlagsTest, ProjectIDConflictWithOverride)
	TEST (CvdLoadFlagsTest, OverrideConflictWithProjectID)
	TEST (CvdLoadFlagsTest, DuplicateOverridesFail)
	TEST (FlagsParserTest, ParseMediaSplaneSingleInstance)
	TEST (FlagsParserTest, ParseMediaSplaneTwoDevices)
	TEST (FlagsParserTest, ParseMediaMplane)
	TEST (FlagsParserTest, ParseMediaV4l2Proxy)
	TEST (ConnectivityFlagsParserTest, ParseModemSimulatorSimTypeValidInt)
	TEST (ConnectivityFlagsParserTest, ParseModemSimulatorSimTypeValidString)
	TEST (ConnectivityFlagsParserTest, ParseModemSimulatorSimTypeUnspecified)
	TEST (ConnectivityFlagsParserTest, ParseModemSimulatorSimTypeInvalidString)
	TEST (ConnectivityFlagsParserTest, ParseModemSimulatorSimTypeInvalidInt)
	TEST (ConfigFlagsParserTest, ParseSingleInstanceConfig)
	TEST (ConfigFlagsParserTest, ParseMultiInstanceConfig)
	TEST (ConfigFlagsParserTest, ParseMultiInstanceConfigPartial)
	TEST (BootFlagsParserTest, ParseTwoInstancesBootAnimationFlagEmptyJson)
	TEST (BootFlagsParserTest, ParseTwoInstancesBootAnimationFlagPartialJson)
	TEST (BootFlagsParserTest, ParseTwoInstancesBootAnimationFlagFullJson)
	TEST (BootFlagsParserTest, ParseTwoInstancesSerialNumberFlagEmptyJson)
	TEST (BootFlagsParserTest, ParseTwoInstancesSerialNumberFlagPartialJson)
	TEST (BootFlagsParserTest, ParseTwoInstancesSerialNumberFlagFullJson)
	TEST (BootFlagsParserTest, ParseTwoInstancesEnforceSecurityFlagEmptyJson)
	TEST (BootFlagsParserTest, ParseTwoInstancesEnforceSecurityFlagPartialJson)
	TEST (BootFlagsParserTest, ParseTwoInstancesEnforceSecurityFlagFullJson)
static bool	EnableBootAnimation (const Instance &instance)
static Result< std::string >	BootCfgArgs (const Instance &instance)
Result< std::vector< std::string > >	GenerateBootFlags (const EnvironmentSpecification &cfg)
Result< std::vector< std::string > >	GenerateBootFlags (const cvd::config::EnvironmentSpecification &)
static std::string	VsockGuestGroup (const Instance &instance)
static int32_t	ModemSimulatorSimType (const Instance &instance)
std::vector< std::string >	GenerateConnectivityFlags (const EnvironmentSpecification &cfg)
std::vector< std::string >	GenerateConnectivityFlags (const cvd::config::EnvironmentSpecification &)
std::vector< std::string >	GenerateDiskFlags (const EnvironmentSpecification &config)
std::vector< std::string >	GenerateDiskFlags (const cvd::config::EnvironmentSpecification &)
Result< std::vector< std::string > >	GenerateGraphicsFlags (const EnvironmentSpecification &cfg)
Result< std::vector< std::string > >	GenerateGraphicsFlags (const cvd::config::EnvironmentSpecification &)
Result< std::vector< std::string > >	GenerateMediaFlags (const EnvironmentSpecification &cfg)
Result< std::vector< std::string > >	GenerateMediaFlags (const cvd::config::EnvironmentSpecification &cfg)
std::vector< std::string >	GenerateSecurityFlags (const EnvironmentSpecification &cfg)
std::vector< std::string >	GenerateSecurityFlags (const cvd::config::EnvironmentSpecification &cfg)
std::string	DeviceId (const Instance &instance)
std::vector< std::string >	GenerateStreamingFlags (const EnvironmentSpecification &cfg)
std::vector< std::string >	GenerateStreamingFlags (const cvd::config::EnvironmentSpecification &)
static std::string	VmManager (const Instance &instance)
static uint32_t	Cpus (const Instance &instance)
static uint32_t	MemoryMb (const Instance &instance)
static bool	UseSdcard (const Instance &instance)
static Result< std::string >	SetupWizardMode (const Instance &instance)
static std::string	Uuid (const Instance &instance)
static bool	EnableSandbox (const Instance &instance)
static bool	SimpleMediaDevice (const Instance &instance)
static std::string	V4l2Proxy (const Instance &instance)
static std::string	VhostUserVsock (const Instance &instance)
static bool	EnablePkvm (const Instance &instance)
static std::vector< std::string >	UserPageSize (const EnvironmentSpecification &cfg)
static Result< std::optional< std::string > >	CustomConfigsFlagValue (const Instance &instance)
static Result< std::vector< std::string > >	CustomConfigsFlags (const EnvironmentSpecification &cfg)
Result< std::vector< std::string > >	GenerateVmFlags (const EnvironmentSpecification &cfg)
Result< std::vector< std::string > >	GenerateVmFlags (const cvd::config::EnvironmentSpecification &)
	TEST (BootFlagsParserTest, ParseTwoInstancesBlankDataImageEmptyJson)
	TEST (BootFlagsParserTest, ParseTwoInstancesBlankDataImagePartialJson)
	TEST (BootFlagsParserTest, ParseTwoInstancesBlankDataImageFullJson)
static void	AssertProtoEquals (const Message &expected, const Message &actual)
InstanceDisplays	DefaultDisplays ()
Result< std::optional< InstancesDisplays > >	DisplaysFlag (std::vector< std::string > args)
	TEST (BootFlagsParserTest, ParseTwoInstancesDisplaysFlagEmptyJson)
	TEST (BootFlagsParserTest, ParseTwoInstancesDisplaysFlagEmptyGraphics)
	TEST (BootFlagsParserTest, ParseTwoInstancesDisplaysFlagEmptyDisplays)
	TEST (BootFlagsParserTest, ParseTwoInstancesAutoTabletDisplaysFlag)
	TEST (VmFlagsParserTest, ParseTwoInstancesCpuFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesQemu)
	TEST (VmFlagsParserTest, ParseTwoInstancesCpuFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesMemoryFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesMemoryFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSdCardFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSdCardFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesVmManagerFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesVmManagerFlagDefault)
	TEST (VmFlagsParserTest, ParseOneInstanceSetupWizardInvalidValue)
	TEST (VmFlagsParserTest, ParseTwoInstancesSetupWizardFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSetupWizardFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesUuidFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesUuidFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSandboxFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSandboxFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSimpleMediaDeviceFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSimpleMediaDeviceFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesV4l2ProxyFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesV4l2ProxyFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesCustomActionsFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesCustomActionsFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesVhostUserVsockFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesVhostUserVsockFlagFullJson)
Result< std::vector< std::string > >	ParseLaunchCvdConfigs (EnvironmentSpecification launch)
Result< std::vector< std::string > >	ParseLaunchCvdConfigs (cvd::config::EnvironmentSpecification)
static Result< Json::Value >	LoadTemplateByName (const std::string &template_name)
Result< EnvironmentSpecification >	ExtractLaunchTemplates (EnvironmentSpecification config)
Result< cvd::config::EnvironmentSpecification >	ExtractLaunchTemplates (cvd::config::EnvironmentSpecification config)
std::vector< Flag >	BuildCvdLoadFlags (LoadFlags &load_flags)
Result< InstanceManager::GroupDirectories >	GetGroupCreationDirectories (const std::string &parent_directory, const EnvironmentSpecification &env_spec)
Result< CvdFlags >	ParseCvdConfigs (const EnvironmentSpecification &env_spec, const LocalInstanceGroup &group)
Result< EnvironmentSpecification >	GetEnvironmentSpecification (const std::string &config_path, const std::map< std::string, std::string, std::less< void > > &overrides)
Result< InstanceManager::GroupDirectories >	GetGroupCreationDirectories (const std::string &parent_directory, const cvd::config::EnvironmentSpecification &env_spec)
Result< CvdFlags >	ParseCvdConfigs (const cvd::config::EnvironmentSpecification &env_spec, const LocalInstanceGroup &group)
selector::SelectorOptions	ParseSelectorConfigs (const EnvironmentSpecification &config)
selector::SelectorOptions	ParseSelectorConfigs (const cvd::config::EnvironmentSpecification &)
bool	ParseJsonString (std::string &json_text, Json::Value &root)
bool	FindConfig (const std::vector< std::string > &vec, const std::string &element)
bool	FindConfigIgnoreSpaces (const std::vector< std::string > &vec, const std::string &str)
Result< std::vector< std::string > >	LaunchCvdParserTester (const Json::Value &root)
Result< CvdCommandHandler * >	RequestHandler (const CommandRequest &request, const std::vector< std::unique_ptr< CvdCommandHandler > > &handlers)
	TEST_F (CvdFlagCollectionTest, Init)
	TEST_F (CvdFlagCollectionTest, Leftover)
	TEST_F (CvdFlagCollectionTest, AllGivenFlagsListed)
	TEST (CvdFlagTest, FlagProxyFilter)
	TEST (HostToolTarget, KnownFlags)
	TEST (HostToolManager, KnownBins)
Result< void >	CheckProcessExitedNormally (siginfo_t infop, int expected_exit_code)
static Command	FixGroupsIfNecessary (const std::string &command_name, const std::string &bin_path)
Result< Command >	ConstructCommand (const ConstructCommandParam &param)
Result< Command >	ConstructCvdHelpCommand (const std::string &bin_file, std::unordered_map< std::string, std::string > envs, const std::vector< std::string > &subcmd_args, const CommandRequest &request)
Result< Command >	ConstructSiblingHelpCommand (const std::string &bin_name, const std::unordered_map< std::string, std::string > &env, const std::vector< std::string > &subcmd_args)
Result< Command >	ConstructCvdGenericNonHelpCommand (const ConstructNonHelpForm &request_form, const CommandRequest &request)
Result< std::vector< Flag > >	GetSiblingCommandFlags (const std::string &bin_name, const std::unordered_map< std::string, std::string > &env, std::vector< std::string > args)
std::string	NoGroupMessage (const CommandRequest &request)
Result< TerminalSize >	GetTerminalSize ()
std::vector< std::string >	ExpandProductPaths (const std::string &product_path, size_t num_instances)
static Result< void >	EnforceHostConfigured ()
Result< bool >	ShouldAutoLogin (const BuildApiFlags &flags)
bool	CanRunAutoLogin ()
Result< void >	RunLogin ()
Result< std::unique_ptr< CredentialSource > >	GetCredentialSourceFromFlags (HttpClient &http_client, const BuildApiFlags &flags, const std::string &oauth_filepath, const std::string &scope)
std::string	GetAcloudOauthFilepath ()
Result< void >	DeAndroidSparse2 (const std::vector< std::string > &image_files)
	TEST_F (FetchCvdTests, CasDownloaderNotCalledIfNoFlags)
	TEST_F (FetchCvdTests, CasDownloaderInvokedIfDownloaderPathSetOnCommandLine)
	TEST_F (FetchCvdTests, CasDownloaderInvokedIfDownloaderPathSetInCasConfig)
Result< std::vector< std::string > >	ExtractImageContents (const std::string &image_filepath, const std::string &target_dir, const bool keep_archive)
std::ostream &	operator<< (std::ostream &out, const FetchBuildContext &context)
std::string	GetFetchLogsFileName (const std::string &target_directory)
Result< FetchResult >	FetchCvdMain (const FetchFlags &flags)
	TEST (FetchCvdParserTests, CreatesCasDownloaderFlags)
template<typename T >
std::optional< T >	GetOptional (const std::vector< T > &vector, size_t i)
template<typename T >
std::optional< T >	GetOptional (const std::vector< std::optional< T > > &vector, size_t i)
Result< void >	FetchHostPackage (BuildApi &build_api, const Build &build, const std::string &target_dir, const bool keep_archives, const std::vector< std::string > &host_substitutions, FetchTracer::Trace trace)
Result< void >	HostPackageSubstitution (const std::string &target_dir, const std::vector< std::string > &host_substitutions)
Result< void >	SymlinkHostPackage (const std::string &target_dir)
Result< std::string >	GetCuttlefishConfigPath (const std::string &home)
bool	IsValidGroupName (const std::string &token)
bool	IsValidInstanceName (const std::string &token)
Result< DeviceName >	BreakDeviceName (const std::string &device_name)
bool	IsValidDeviceName (const std::string &token)
Result< TimeStamp >	DeserializeTimePoint (const Json::Value &time_point_json)
std::string	Format (const TimeStamp &time_point)
static Result< void >	SetStatus (SharedFD &fd, const InUseState state)
Result< std::vector< GroupProcInfo > >	CollectRunCvdGroups ()
Result< std::vector< pid_t > >	CollectRunCvdProcesses ()
Result< Json::Value >	FetchInstanceStatus (LocalInstance &instance, std::chrono::seconds timeout)
std::string	HumanFriendlyStateName (cvd::InstanceState state)
Result< void >	KillAllCuttlefishInstances (bool clear_runtime_dirs)
Result< void >	ForcefullyStopGroup (const uid_t any_id_in_group)
Result< void >	RunStopCvd (StopCvdParams params)
Result< std::string >	AndroidHostPath (const std::unordered_map< std::string, std::string > &envs)
template<typename T >
std::ostream &	operator<< (std::ostream &out, const std::vector< T > &v)
std::string	CvdDir ()
std::string	PerUserDir ()
std::string	PerUserCacheDir ()
std::string	InstanceDatabasePath ()
std::string	InstanceLocksPath ()
Result< std::string >	GroupDirFromHome (std::string_view dir)
std::string	AssemblyDirFromHome (const std::string &group_home_dir)
std::optional< std::vector< FlagInfo > >	CollectFlagsFromHelpxml (const std::string &xml_str)
Result< std::unique_ptr< InterruptListenerHandle > >	PushInterruptListener (InterruptListener listener)
VersionIdentifiers	GetVersionIds ()
	TEST (GpxParser, ParseFileNotFound)
	TEST (GpxParser, ParseEmptyFile)
	TEST (GpxParser, ParseEmptyString)
	TEST (GpxParser, ParseEmptyRteTrkFile)
	TEST (GpxParser, ParseEmptyRteTrkString)
	TEST (GpxParser, ParseValidFile)
	TEST (GpxParser, ParseValidString)
	TEST (GpxParser, ParseFileNullAttributeFile)
	TEST (GpxParser, ParseFileNullAttributeString)
	TEST (GpxParser, ParseLocationMissingLatitudeFile)
	TEST (GpxParser, ParseLocationMissingLatitudeString)
	TEST (GpxParser, ParseLocationMissingLongitudeFile)
	TEST (GpxParser, ParseLocationMissingLongitudeString)
	TEST (GpxParser, ParseValidLocationFile)
	TEST (GpxParser, ParseValidLocationString)
	TEST (GpxParser, ParseValidDocumentFile)
	TEST (GpxParser, ParseValidDocumentString)
	TEST (KmlParser, ParseNonexistentFile)
	TEST (KmlParser, ParseEmptyKmlFile)
	TEST (KmlParser, ParseEmptyKmlString)
	TEST (KmlParser, ParseValidKmlFile)
	TEST (KmlParser, ParseValidKmlString)
	TEST (KmlParser, ParseValidComplexFile)
	TEST (KmlParser, ParseValidComplexString)
	TEST (KmlParser, ParseOneCoordinateFile)
	TEST (KmlParser, ParseOneCoordinateString)
	TEST (KmlParser, ParseMultipleCoordinatesFile)
	TEST (KmlParser, ParseMultipleCoordinatesString)
	TEST (KmlParser, ParseBadCoordinatesFile)
	TEST (KmlParser, ParseBadCoordinatesString)
	TEST (KmlParser, ParseLocationNormalFile)
	TEST (KmlParser, ParseLocationNormalString)
	TEST (KmlParser, ParseLocationNormalMissingOptionalFieldsFile)
	TEST (KmlParser, ParseLocationNormalMissingOptionalFieldsString)
	TEST (KmlParser, ParseLocationMissingRequiredFieldsFile)
	TEST (KmlParser, ParseLocationMissingRequiredFieldsString)
	TEST (KmlParser, ParseLocationNameOnlyFirstFile)
	TEST (KmlParser, ParseLocationNameOnlyFirstString)
	TEST (KmlParser, ParseMultipleLocationsFile)
	TEST (KmlParser, ParseMultipleLocationsString)
	TEST (KmlParser, TraverseEmptyDocFile)
	TEST (KmlParser, TraverseEmptyDocString)
	TEST (KmlParser, TraverseDocNoPlacemarksFile)
	TEST (KmlParser, TraverseDocNoPlacemarksString)
	TEST (KmlParser, TraverseNestedDocFile)
	TEST (KmlParser, TraverseNestedDocString)
	TEST (KmlParser, ParsePlacemarkNullNameNoCrashFile)
	TEST (KmlParser, ParsePlacemarkNullNameNoCrashString)
std::string	GetATCommand (const std::string &plmn, int32_t identifierType, int32_t protocolMessage, bool isEmergency)
std::string	GetATCommand (int32_t connection_event, int32_t encryption, int32_t integrity, bool is_unprotected_emergency)
Result< int >	CvdallocMain (int argc, char *argv[])
std::string	CvdallocInterfaceName (const std::string &name, int num)
std::string	InstanceToMobileGatewayAddress (int num)
std::string	InstanceToMobileAddress (int num)
std::string	InstanceToMobileBroadcast (int num)
std::string	InstanceToWifiGatewayAddress (int num)
std::string	InstanceToWifiAddress (int num)
std::string	InstanceToWifiBroadcast (int num)
std::string	InstanceToBridgedWifiGatewayAddress (int num)
std::string	InstanceToBridgedWifiAddress (int num)
std::string	InstanceToBridgedWifiBroadcast (int num)
Result< void >	ValidateCvdallocBinary (std::string_view path)
int	BeginElevatedPrivileges ()
int	DropPrivileges (uid_t orig)
Result< int >	DefaultsMain (int argc, char *argv[])
Result< void >	MkenvimageSlimMain (int argc, char **argv)
static int	parse_int (const std::string &snumber, int base)
const std::pair< int, int >	kSimPinSizeRange (4, 8)
template<typename T >
std::function< void()>	makeSafeCallback (T *me, std::function< void(T *)> f)
template<typename T , typename... Params>
std::function< void()>	makeSafeCallback (T *obj, void(T::*f)(const Params &...), const Params &... params)
template<typename T , typename... Params>
std::function< void()>	makeSafeCallback (T *obj, void(T::*f)(Params...), const Params &... params)
fruit::Component< fruit::Required< const CuttlefishConfig, KernelLogPipeProvider, const CuttlefishConfig::InstanceSpecific, const vm_manager::VmManager, AutoSetup< ValidateTapDevices >::Type > >	bootStateMachineComponent ()
std::optional< MonitorCommand >	AutomotiveProxyService (const CuttlefishConfig &config)
Result< std::optional< MonitorCommand > >	BluetoothConnector (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance)
Result< std::vector< MonitorCommand > >	Casimir (const CuttlefishConfig &config, const CuttlefishConfig::EnvironmentSpecific &environment, const CuttlefishConfig::InstanceSpecific &instance, LogTeeCreator &log_tee)
Result< std::optional< MonitorCommand > >	CasimirControlServer (const CuttlefishConfig &config, const CuttlefishConfig::EnvironmentSpecific &environment, const CuttlefishConfig::InstanceSpecific &instance, GrpcSocketCreator &grpc_socket)
std::string	ConsoleInfo (const CuttlefishConfig::InstanceSpecific &instance)
Result< std::optional< MonitorCommand > >	ConsoleForwarder (const CuttlefishConfig::InstanceSpecific &instance)
fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific, GrpcSocketCreator > >	ControlEnvProxyServerComponent ()
fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific > >	CvdallocComponent ()
MonitorCommand	EchoServer (GrpcSocketCreator &grpc_socket)
bool	ShouldEnableMultitouch (const CuttlefishConfig::InstanceSpecific &instance)
Result< std::optional< MonitorCommand > >	GnssGrpcProxyServer (const CuttlefishConfig::InstanceSpecific &instance, GrpcSocketCreator &grpc_socket)
fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific >, InputPathsProvider, LogTeeCreator >	VhostInputDevicesComponent ()
fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific >, KernelLogPipeProvider >	KernelLogMonitorComponent ()
Result< MonitorCommand >	LogcatReceiver (const CuttlefishConfig::InstanceSpecific &instance)
fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific, LogTeeCreator > >	McuComponent ()
static StopperResult	StopModemSimulator (int id)
Result< std::optional< MonitorCommand > >	ModemSimulator (const CuttlefishConfig::InstanceSpecific &instance)
fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific, GrpcSocketCreator > >	NetsimServerComponent ()
Result< std::optional< MonitorCommand > >	NfcConnector (const CuttlefishConfig &config, const CuttlefishConfig::EnvironmentSpecific &environment, const CuttlefishConfig::InstanceSpecific &instance)
fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::EnvironmentSpecific, const CuttlefishConfig::InstanceSpecific, LogTeeCreator, WmediumdServer, Cvdalloc > >	OpenWrtComponent ()
fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::EnvironmentSpecific, GrpcSocketCreator > >	OpenwrtControlServerComponent ()
Result< std::vector< MonitorCommand > >	Pica (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance, LogTeeCreator &log_tee)
fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific, LogTeeCreator > >	RootCanalComponent ()
Result< std::optional< MonitorCommand > >	ScreenRecordingServer (GrpcSocketCreator &grpc_socket)
Result< MonitorCommand >	SecureEnv (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance, AutoSnapshotControlFiles::Type &snapshot_control_files, KernelLogPipeProvider &kernel_log_pipe_provider)
Result< MonitorCommand >	SensorsSimulator (const CuttlefishConfig::InstanceSpecific &instance, AutoSensorsSocketPair::Type &sensors_socket_pair, KernelLogPipeProvider &kernel_log_pipe_provider)
fruit::Component< fruit::Required< const CuttlefishConfig, KernelLogPipeProvider, InputPathsProvider, const CuttlefishConfig::InstanceSpecific, const CustomActionConfigProvider, WebRtcController > >	launchStreamerComponent ()
fruit::Component< fruit::Required< const CuttlefishConfig, LogTeeCreator, const CuttlefishConfig::InstanceSpecific > >	Ti50EmulatorComponent ()
Result< MonitorCommand >	TombstoneReceiver (const CuttlefishConfig::InstanceSpecific &instance)
Result< std::optional< MonitorCommand > >	UwbConnector (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance)
std::optional< MonitorCommand >	VhalProxyServer (const CuttlefishConfig::InstanceSpecific &instance)
fruit::Component< fruit::Required< const CuttlefishConfig, LogTeeCreator, const CuttlefishConfig::InstanceSpecific > >	VhostDeviceVsockComponent ()
fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific, LogTeeCreator > >	VhostUserMediaDevicesComponent ()
fruit::Component< WebRtcController >	WebRtcControllerComponent ()
fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::EnvironmentSpecific, const CuttlefishConfig::InstanceSpecific, LogTeeCreator, GrpcSocketCreator > >	WmediumdServerComponent ()
Result< void >	RunCvdMain (int argc, char **argv)
fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific, AutoSnapshotControlFiles::Type, WebRtcController >, ServerLoop >	serverLoopComponent ()
static Result< void >	TestTapDevices (const CuttlefishConfig::InstanceSpecific &instance)
Result< void >	ValidateTapDevices (const CuttlefishConfig::InstanceSpecific &instance)
Result< void >	ValidateHostConfiguration ()
Result< void >	ValidateHostKernel ()
static void	FinalizeTcti (TSS2_TCTI_CONTEXT *tcti_context)
static bool	CreateKey (TpmResourceManager &resource_manager, ESYS_TR parent_key, TPM2B_PUBLIC *key_public_out, TPM2B_PRIVATE *key_private_out, TpmObjectSlot *key_slot_out)
static TpmObjectSlot	LoadKey (TpmResourceManager &resource_manager, ESYS_TR parent_key, const TPM2B_PUBLIC *key_public, const TPM2B_PRIVATE *key_private)
static uint32_t	RoundUpToBlockSize (uint32_t num)
	TEST (TpmEncryptedSerializable, BinaryData)
struct	__attribute__ ((__packed__)) tpm_message_header
bool	WriteProtectedJsonToFile (TpmResourceManager &resource_manager, const std::string &filename, Json::Value json)
Json::Value	ReadProtectedJsonFromFile (TpmResourceManager &resource_manager, const std::string &filename)
std::function< TpmObjectSlot(TpmResourceManager &)>	SigningKeyCreator (const std::string &unique)
std::function< TpmObjectSlot(TpmResourceManager &)>	ParentKeyCreator (const std::string &unique)
Result< void >	SecureEnvMain (int argc, char **argv)
bool	matchAttestationId (keymaster_blob_t blob, const std::vector< uint8_t > &id)
std::string	TpmCommandName (uint32_t command_num)
static bool	TpmEncryptDecrypt (ESYS_CONTEXT *esys, ESYS_TR key_handle, TpmAuth auth, const TPM2B_IV &iv, uint8_t *data_in, uint8_t *data_out, size_t data_size, bool decrypt)
bool	TpmEncrypt (ESYS_CONTEXT *esys, ESYS_TR key_handle, TpmAuth auth, const TPM2B_IV &iv, uint8_t *data_in, uint8_t *data_out, size_t data_size)
bool	TpmDecrypt (ESYS_CONTEXT *esys, ESYS_TR key_handle, TpmAuth auth, const TPM2B_IV &iv, uint8_t *data_in, uint8_t *data_out, size_t data_size)
gatekeeper::failure_record_t	DefaultRecord (gatekeeper::secure_id_t secure_user_id)
static Result< secure_env::ManagedStorageData >	RecordToStorageData (const gatekeeper::failure_record_t &record)
static Result< gatekeeper::failure_record_t >	StorageDataToRecord (const secure_env::StorageData &data)
static Result< void >	GetFailureRecordImpl (secure_env::Storage &storage, uint32_t uid, gatekeeper::secure_id_t secure_user_id, gatekeeper::failure_record_t *record)
static Result< void >	WriteFailureRecordImpl (secure_env::Storage &storage, uint32_t uid, gatekeeper::failure_record_t *record)
static UniqueEsysPtr< TPM2B_DIGEST >	OneshotHmac (TpmResourceManager &resource_manager, ESYS_TR key_handle, TpmAuth auth, const uint8_t *data, size_t data_size)
static UniqueEsysPtr< TPM2B_DIGEST >	SegmentedHmac (TpmResourceManager &resource_manager, ESYS_TR key_handle, TpmAuth key_auth, const uint8_t *data, size_t data_size)
UniqueEsysPtr< TPM2B_DIGEST >	TpmHmac (TpmResourceManager &resource_manager, ESYS_TR key_handle, TpmAuth auth, const uint8_t *data, size_t data_size)
UniqueEsysPtr< TPM2B_DIGEST >	TpmHmacWithContext (TpmResourceManager &resource_manager, const std::string &context, const uint8_t *data, size_t data_size)
static keymaster_error_t	SplitEnforcedProperties (const keymaster::AuthorizationSet &key_description, keymaster::AuthorizationSet *hw_enforced, keymaster::AuthorizationSet *sw_enforced, keymaster::AuthorizationSet *hidden)
static KeymasterKeyBlob	SerializableToKeyBlob (const Serializable &serializable)
static bool	UpgradeIntegerTag (keymaster_tag_t tag, uint32_t value, AuthorizationSet *set, bool *set_changed)
std::string	ToHexString (const std::vector< uint8_t > &binary)
Result< Parsed >	Parse (int argc, char **argv)
Result< SnapshotCmd >	ConvertToSnapshotCmd (const std::string &input)
static Result< std::vector< int > >	InstanceNums ()
Result< Parsed >	Parse (std::vector< std::string > &args)
std::ostream &	operator<< (std::ostream &out, const SnapshotCmd &cmd)
Result< std::string >	HandleHostGroupSnapshot (const std::string &path)
FetcherConfig	AvailableFilesReport ()
std::vector< std::string >	OverrideBoolArg (std::vector< std::string > args, const std::unordered_set< std::string > &flag_set)
static std::string	next_tombstone_path (const std::string &dir)
int	TombstoneReceiverMain (int argc, char **argv)
void	EstablishAndMaintainConnection (const std::string &address)
int	AdbConnectorMain (int argc, char *argv[])
static constexpr uint8_t	GetChannelsCount (AudioChannelsLayout layout)
uint16_t	JsIndexToLinux (const int32_t &index_code)
std::unique_ptr< AudioServer >	CreateAudioServer ()
fruit::Component< CustomActionConfigProvider >	WebRtcComponent ()
fruit::Component< ScreenConnector< DisplayHandler::WebRtcScProcessedFrame >, confui::HostServer, confui::HostVirtualInput >	CreateConfirmationUIComponent (int *frames_fd, bool *frames_are_rgba, confui::PipeConnectionPair *pipe_io_pair, InputConnector *input_connector)
Result< void >	ControlLoop (SharedFD control_socket, DisplayHandler &display_handler, RecordingManager &recording_manager, ScreenshotHandler &screenshot_handler)
AudioChannelsLayout	ConvertChannelLayout (::cuttlefish::config::Audio_ChannelLayout layout)
uint32_t	ConvertSampleRate (::cuttlefish::config::Audio_SampleRate rate)
cuttlefish::AudioStreamSettings	ParseAudioStreamSettings (const ::cuttlefish::config::Audio_PCMDevice_Stream &stream, AudioStreamSettings::Direction direction)
std::shared_ptr< AudioHandler >	SetupAudio (const cuttlefish::CuttlefishConfig::InstanceSpecific &instance, cuttlefish::webrtc_streaming::Streamer &streamer)
int	CuttlefishMain ()
	ASSERT_VALID_MSG_TYPE (virtio_snd_query_info, 16)
	ASSERT_VALID_MSG_TYPE (virtio_snd_jack_info, 24)
	ASSERT_VALID_MSG_TYPE (virtio_snd_chmap_info, 24)
	ASSERT_VALID_MSG_TYPE (virtio_snd_pcm_info, 32)
	ASSERT_VALID_MSG_TYPE (virtio_snd_pcm_set_params, 24)
	ASSERT_VALID_MSG_TYPE (virtio_snd_pcm_hdr, 8)
	ASSERT_VALID_MSG_TYPE (virtio_snd_ctl_info, 96)
	ASSERT_VALID_MSG_TYPE (virtio_snd_ctl_hdr, 8)
	ASSERT_VALID_MSG_TYPE (virtio_snd_ctl_value, 512)
	ASSERT_VALID_MSG_TYPE (IoTransferMsg, 12)
	ASSERT_VALID_MSG_TYPE (IoStatusMsg, 16)
Result< void >	EnforceVbMetaSize (const std::string &path)
std::ostream &	operator<< (std::ostream &out, LauncherResponse response)
Result< void >	CopyDirectoryRecursively (const std::string &src_dir_path, const std::string &dest_dir_path, const bool verify_dest_dir_empty, std::function< bool(const std::string &)> predicate)
Result< std::string >	InstanceGuestSnapshotPath (const Json::Value &meta_json, const std::string &instance_id)
Result< Json::Value >	CreateMetaInfo (const CuttlefishConfig &cuttlefish_config, const std::string &snapshot_path)
std::string	SnapshotMetaJsonPath (const std::string &snapshot_path)
Result< Json::Value >	LoadMetaJson (const std::string &snapshot_path)
Result< std::vector< std::string > >	GuestSnapshotDirectories (const std::string &snapshot_path)
Result< RunnerExitCodes >	ReadExitCode (SharedFD monitor_socket)
Result< SharedFD >	GetLauncherMonitorFromInstance (const CuttlefishConfig::InstanceSpecific &instance_config, const int timeout_seconds)
Result< SharedFD >	GetLauncherMonitor (const CuttlefishConfig &config, const int instance_num, int timeout_seconds)
Result< std::optional< LauncherActionInfo > >	ReadLauncherActionFromFd (SharedFD monitor_socket)
Result< void >	WaitForRead (SharedFD monitor_socket, const int timeout_seconds)
Result< void >	RunLauncherAction (SharedFD monitor_socket, LauncherAction action, std::optional< int > timeout_seconds)
Result< void >	RunLauncherAction (SharedFD monitor_socket, const run_cvd::ExtendedLauncherAction &extended_action, std::optional< int > timeout_seconds)
AdbMode	StringToAdbMode (std::string_view mode)
std::string	AdbModeToString (AdbMode mode)
fruit::Component< AdbConfig >	AdbConfigComponent ()
fruit::Component< fruit::Required< AdbConfig, ConfigFlag >, AdbConfigFlag >	AdbConfigFlagComponent ()
fruit::Component< fruit::Required< AdbConfig >, AdbConfigFragment >	AdbConfigFragmentComponent ()
fruit::Component< fruit::Required< KernelLogPipeProvider, const AdbConfig, const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific > >	LaunchAdbComponent ()
fruit::Component< TestData >	TestComponent ()
	TEST (AdbConfigTest, SetFromFlags)
	TEST (AdbConfigTest, SerializeDeserialize)
std::string	format_as (const BuildArchive &archive)
std::ostream &	operator<< (std::ostream &out, const BuildArchive &build_archive)
PrettyStruct	Pretty (const BuildArchive &archive, PrettyAdlPlaceholder)
fruit::Component< fruit::Required< SystemImageDirFlag >, ConfigFlag >	ConfigFlagComponent ()
fruit::Component< ConfigFlag >	ConfigFlagPlaceholder ()
std::string	AccessKregistryPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	ConsoleInPipeName (const CuttlefishConfig::InstanceSpecific &ins)
std::string	ConsoleOutPipeName (const CuttlefishConfig::InstanceSpecific &ins)
std::string	ConsolePath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	ConsolePipePrefix (const CuttlefishConfig::InstanceSpecific &ins)
std::string	GamepadSocketPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	GamepadEventsServerPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	GamepadCaptureServerPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	HwcomposerPmemPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	KernelLogPipeName (const CuttlefishConfig::InstanceSpecific &ins)
std::string	KeyboardSocketPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	KeyboardEventsServerPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	KeyboardCaptureServerPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	LauncherMonitorSocketPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	LogcatPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	LogcatPipeName (const CuttlefishConfig::InstanceSpecific &ins)
std::string	MouseSocketPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	MouseEventsServerPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	MouseCaptureServerPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	PflashPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	PstorePath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	RotarySocketPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	RotaryEventsServerPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	RotaryCaptureServerPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	SwitchesSocketPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	SwitchesEventsServerPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	SwitchesCaptureServerPath (const CuttlefishConfig::InstanceSpecific &ins)
std::string	RestoreAdbdPipeName (const CuttlefishConfig::InstanceSpecific &ins)
int	InstanceFromString (std::string instance_str)
int	InstanceFromEnvironment ()
int	GetInstance ()
int	GetDefaultVsockCid ()
int	GetVsockServerPort (const int base, const int vsock_guest_cid)
std::string	GetGlobalConfigFileLink ()
std::string	ForCurrentInstance (const char *prefix)
std::string	RandomSerialNumber (const std::string &prefix)
std::string	DefaultHostArtifactsPath (const std::string &file_name)
std::string	HostBinaryDir ()
bool	UseQemuPrebuilt ()
std::string	DefaultQemuBinaryDir ()
std::string	HostBinaryPath (const std::string &binary_name)
std::string	HostUsrSharePath (const std::string &file)
std::string	HostQemuBiosPath ()
std::string	DefaultGuestImagePath (const std::string &file_name)
std::string	DefaultEnvironmentPath (const std::string &environment_key, const std::string &default_value, const std::string &subpath)
bool	IsValidAndroidHostOutPath (const std::string &path)
bool	HostSupportsQemuCli ()
std::string	GetSeccompPolicyDir ()
fruit::Component< fruit::Required< ConfigFlag >, CustomActionConfigProvider >	CustomActionsComponent ()
bool	IsRestoring (const CuttlefishConfig &config)
bool	EnableNetsimNfc (const CuttlefishConfig &config)
bool	VmManagerIsCrosvm (const CuttlefishConfig &config)
bool	VmManagerIsQemu (const CuttlefishConfig &config)
bool	VmManagerIsGem5 (const CuttlefishConfig &config)
Result< void >	CreateBlankEmptyImage (std::string_view image, int num_mb)
Result< void >	CreateBlankExt4Image (std::string_view image, int num_mb)
Result< void >	CreateBlankSdcardImage (std::string_view image, int num_mb)
Result< void >	InitializeDataImage (const CuttlefishConfig::InstanceSpecific &instance)
static bool	EspRequiredForBootFlow (BootFlow flow)
static bool	EspRequiredForAPBootFlow (APBootFlow ap_boot_flow)
static void	InitLinuxArgs (Arch target_arch, LinuxEspBuilder &linux_esp_builder)
static void	InitChromeOsArgs (LinuxEspBuilder &linux_esp_builder)
static bool	BuildAPImage (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance)
static bool	BuildOSImage (const CuttlefishConfig::InstanceSpecific &instance)
Result< void >	InitializeEspImage (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance)
DataImagePolicy	DataImagePolicyFromString (std::string_view policy)
std::string	DataImagePolicyString (DataImagePolicy policy)
Result< std::optional< CuttlefishConfig::DisplayConfig > >	ParseDisplayConfig (const std::string &flag)
Result< std::vector< CuttlefishConfig::DisplayConfig > >	ParseDisplayConfigsFromArgs (std::vector< std::string > &args)
bool	CanGenerateGrubEsp (Arch arch)
template<typename T >
static bool	GrubMakeImage (const std::string &prefix, const std::string &format, const std::string &directory, const std::string &output, const T &modules)
EspBuilder	PrepareGrubESP (const std::string &image_path, Arch arch)
EspBuilder	AddGrubConfig (const std::string &config)
static bool	MsdosMakeDirectories (const std::string &image_path, const std::vector< std::string > &directories)
static bool	CopyToMsdos (const std::string &image, const std::string &path, const std::string &destination)
Result< void >	MakeFatImage (const std::string &data_image, int data_image_mb, int offset_num_mb)
std::ostream &	operator<< (std::ostream &out, ExternalNetworkMode net)
Result< ExternalNetworkMode >	ParseExternalNetworkMode (std::string_view str)
std::string_view	format_as (ExternalNetworkMode net)
fruit::Component< fruit::Required< FastbootConfig >, FastbootConfigFragment >	FastbootConfigFragmentComponent ()
fruit::Component< FastbootConfig >	FastbootConfigComponent ()
fruit::Component< fruit::Required< FastbootConfig, ConfigFlag >, FastbootConfigFlag >	FastbootConfigFlagComponent ()
fruit::Component< fruit::Required< KernelLogPipeProvider, const CuttlefishConfig::InstanceSpecific, const FastbootConfig > >	LaunchFastbootComponent ()
std::ostream &	operator<< (std::ostream &os, const CvdFile &cvd_file)
Result< CvdFile >	BuildFetcherConfigMember (FileSource purpose, std::string build_id, std::string build_target, std::string path, std::string directory_prefix, std::string archive_source, std::string archive_path)
FileSource	SourceStringToEnum (std::string_view source)
std::string_view	SourceEnumToString (FileSource source)
std::ostream &	operator<< (std::ostream &out, FileSource source)
std::string_view	format_as (FileSource source)
template<typename Sink >
void	AbslStringify (Sink &sink, FileSource file_source)
Result< GpuMode >	GpuModeFromString (std::string_view mode)
std::string	GpuModeString (GpuMode mode)
std::string_view	format_as (GpuMode mode)
bool	IsGfxstreamMode (GpuMode mode)
bool	IsGfxstreamGuestAngleMode (GpuMode mode)
bool	IsGuestRenderingMode (GpuMode mode)
template<typename Sink >
void	AbslStringify (Sink &sink, GpuMode mode)
std::ostream &	operator<< (std::ostream &out, GuestHwuiRenderer renderer)
std::string	ToString (GuestHwuiRenderer renderer)
Result< GuestHwuiRenderer >	ParseGuestHwuiRenderer (std::string_view str)
GuestOs	GuestOsFromBootFlow (BootFlow boot_flow)
std::ostream &	operator<< (std::ostream &out, GuestRendererPreload preload)
std::string	ToString (GuestRendererPreload preload)
Result< GuestRendererPreload >	ParseGuestRendererPreload (std::string_view str)
uint32_t	FileCrc (const std::string &path)
static std::map< std::string, uint32_t >	DirectoryCrc (const std::string &path)
std::map< std::string, uint32_t >	HostToolsCrc ()
static Result< std::optional< int32_t > >	ParseBaseInstanceFlag (std::vector< std::string > &flags)
static Result< std::optional< int32_t > >	ParseNumInstancesFlag (std::vector< std::string > &flags)
static Result< std::vector< int32_t > >	ParseInstanceNums (const std::string &instance_nums_str)
static Result< std::vector< int32_t > >	ParseInstanceNumsFlag (std::vector< std::string > &flags)
static Result< std::optional< int32_t > >	GflagsBaseInstanceFlag ()
static Result< std::optional< int32_t > >	GflagsNumInstancesFlag ()
static Result< std::vector< int32_t > >	GflagsInstanceNumsFlag ()
std::vector< std::string >	KernelCommandLineFromConfig (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance)
std::string	AdbConnectorBinary ()
std::string	AutomotiveProxyBinary ()
std::string	AvbToolBinary ()
std::string	CasimirBinary ()
std::string	CasimirControlServerBinary ()
std::string	ConsoleForwarderBinary ()
std::string	ControlEnvProxyServerBinary ()
std::string	CpioBinary ()
std::string	CvdallocBinary ()
std::string	DefaultKeyboardSpec ()
std::string	DefaultMouseSpec ()
std::string	DefaultGamepadSpec ()
std::string	DefaultMultiTouchpadSpecTemplate ()
std::string	DefaultMultiTouchscreenSpecTemplate ()
std::string	DefaultRotaryDeviceSpec ()
std::string	DefaultSingleTouchpadSpecTemplate ()
std::string	DefaultSingleTouchscreenSpecTemplate ()
std::string	DefaultSwitchesSpec ()
std::string	EchoServerBinary ()
std::string	GnssGrpcProxyBinary ()
std::string	KernelLogMonitorBinary ()
std::string	LogcatReceiverBinary ()
std::string	McopyBinary ()
std::string	MkfsFat ()
std::string	MkuserimgMke2fsBinary ()
std::string	MmdBinary ()
std::string	ModemSimulatorBinary ()
std::string	NetsimdBinary ()
std::string	NewfsMsdos ()
std::string	OpenwrtControlServerBinary ()
std::string	PicaBinary ()
std::string	ProcessRestarterBinary ()
std::string	RootCanalBinary ()
std::string	ScreenRecordingServerBinary ()
std::string	SecureEnvBinary ()
std::string	SensorsSimulatorBinary ()
std::string	Simg2ImgBinary ()
std::string	SocketVsockProxyBinary ()
std::string	StopCvdBinary ()
std::string	TcpConnectorBinary ()
std::string	TestKeyRsa2048 ()
std::string	TestKeyRsa4096 ()
std::string	TestPubKeyRsa2048 ()
std::string	TestPubKeyRsa4096 ()
std::string	TombstoneReceiverBinary ()
std::string	UnpackBootimgBinary ()
std::string	VhalProxyServerBinary ()
std::string	VhalProxyServerConfig ()
std::string	WebRtcBinary ()
std::string	WebRtcSigServerBinary ()
std::string	WebRtcSigServerProxyBinary ()
std::string	WmediumdBinary ()
std::string	WmediumdGenConfigBinary ()
std::string	VhostUserInputBinary ()
std::string	VhostUserMediaEmulatedCameraSPlaneBinary ()
std::string	VhostUserMediaEmulatedCameraMPlaneBinary ()
std::string	VhostUserMediaV4l2StreamProxyBinary ()
Result< void >	LogStringToDir (const CuttlefishConfig::InstanceSpecific &instance, std::string_view name, std::string_view contents)
void	DefaultSubprocessLogging (char *argv[], MetadataLevel stderr_level)
Result< std::optional< CuttlefishConfig::MediaConfig > >	ParseMediaConfig (const std::string &flag)
Result< std::vector< CuttlefishConfig::MediaConfig > >	ParseMediaConfigsFromArgs (std::vector< std::string > &args)
Result< void >	MkenvimageSlim (const std::string &input_path, const std::string &output_path, size_t env_size)
std::unordered_map< std::string, std::string >	OpenwrtArgsFromConfig (const CuttlefishConfig::InstanceSpecific &instance)
Result< SecureHal >	ParseSecureHal (std::string mode)
Result< std::set< SecureHal > >	ParseSecureHals (const std::string &hals)
Result< void >	ValidateSecureHals (const std::set< SecureHal > &secure_hals)
std::string	ToString (SecureHal hal_in)
Result< CuttlefishConfig::TouchpadConfig >	ParseTouchpadConfig (const std::string &flag)
Result< std::vector< CuttlefishConfig::TouchpadConfig > >	ParseTouchpadConfigsFromArgs (std::vector< std::string > &args)
std::string	ToString (VmmMode mode)
std::ostream &	operator<< (std::ostream &out, VmmMode vmm)
Result< VmmMode >	ParseVmm (std::string_view str)
bool	VmManagerIsCrosvm (VmmMode mode)
bool	VmManagerIsQemu (VmmMode mode)
bool	VmManagerIsGem5 (VmmMode mode)
std::string_view	format_as (VmmMode vmm)
Result< std::string >	HandleCmds (const std::string &grpc_socket_path, const std::string &cmd, const std::vector< std::string > &args)
Result< std::string >	CvdDataHome ()
Result< std::string >	CvdConfigHome ()
Result< std::string >	CvdStateHome ()
Result< std::string >	CvdCacheHome ()
std::string	CvdRuntimeDir ()
Result< std::vector< std::string > >	CvdDataDirs ()
Result< std::vector< std::string > >	CvdConfigDirs ()
Result< std::string >	ReadCvdDataFile (std::string_view path)
Result< std::vector< std::string > >	FindCvdDataFiles (std::string_view path)
Result< void >	WriteCvdDataFile (std::string_view path, std::string contents)
template<typename... Args>
std::unordered_set< SetupFeature * >	SetupFeatureDeps (const std::tuple< Args... > &args)
Result< const CudaFunctions * >	TryLoadCuda ()
bool	IsNvencCodecSupported (GUID codec_guid, int device_id)
Result< const NV_ENCODE_API_FUNCTION_LIST * >	TryLoadNvenc ()
struct	__attribute__ ((packed)) GptHeader
Result< const uint8_t * >	GetPartitionGUID (GptPartitionType type)
uint64_t	AlignToPartitionSize (uint64_t size)
Result< void >	AggregateImage (const std::vector< ImagePartition > &partitions, const std::string &output_path)
Result< void >	CreateOrUpdateCompositeDisk (std::vector< ImagePartition > partitions, const std::string &header_file, const std::string &footer_file, const std::string &output_composite_path, bool read_only)
Result< std::unique_ptr< DiskImage > >	ImageFromFile (const std::string &file_path)
MasterBootRecord	ProtectiveMbr (uint64_t size)
Result< bool >	IsSparseImage (const std::string &image_path)
Result< void >	ForceRawImage (const std::string &image_path)
void	alpha_blend_layer (uint8_t *frame_pixels, uint32_t h, uint32_t w, uint8_t *overlay)
Result< void >	StartScreenRecording (const CuttlefishConfig::InstanceSpecific &instance_config, std::chrono::seconds wait_for_launcher)
Result< void >	StopScreenRecording (const CuttlefishConfig::InstanceSpecific &instance_config, std::chrono::seconds wait_for_launcher)
Result< std::vector< std::string > >	CrosvmCpuArguments (const Json::Value &vcpu_config_json)
std::ostream &	operator<< (std::ostream &out, const DeviceBuild &build)
std::ostream &	operator<< (std::ostream &out, const DirectoryBuild &build)
std::ostream &	operator<< (std::ostream &out, const Build &build)
std::string	FetchLabel (const Build &build)
std::tuple< std::string, std::string >	GetBuildIdAndTarget (const Build &build)
std::optional< std::string >	GetFilepath (const Build &build)
std::string	ConstructTargetFilepath (const std::string &directory, const std::string &filename)
std::string	GetCatchallApiKey ()
std::ostream &	operator<< (std::ostream &out, const DeviceBuildString &build_string)
std::ostream &	operator<< (std::ostream &out, const DirectoryBuildString &build_string)
std::ostream &	operator<< (std::ostream &out, const BuildString &build_string)
std::ostream &	operator<< (std::ostream &out, const std::optional< BuildString > &build_string)
std::optional< std::string >	GetFilepath (const BuildString &build_string)
void	SetFilepath (BuildString &build_string, const std::string &value)
Result< BuildString >	ParseBuildString (std::string_view build_string)
Flag	GflagsCompatFlag (const std::string &name, std::optional< BuildString > &value)
Flag	GflagsCompatFlag (const std::string &name, std::vector< std::optional< BuildString > > &value)
BuildString	WithFallbackTarget (BuildString build_string, std::string fallback)
	TEST (ParseBuildStringTests, DeviceBuildStringSuccess)
	TEST (ParseBuildStringTests, DeviceBuildStringNoTargetSuccess)
	TEST (ParseBuildStringTests, DirectoryBuildStringSinglePathSuccess)
	TEST (ParseBuildStringTests, DirectoryBuildStringMultiplePathSuccess)
	TEST (ParseBuildStringTests, EmptyStringFail)
	TEST (ParseBuildStringTests, DeviceBuildStringMultipleSlashesFail)
	TEST (ParseBuildStringTests, FilepathExistsSuccess)
	TEST (ParseBuildStringTests, FilepathExistsMissingBracketFail)
	TEST (ParseBuildStringTests, FilepathBracketsButNoValueFail)
	TEST (ParseBuildStringTests, FilepathOnlyFail)
	TEST (SingleBuildStringGflagsCompatFlagTests, EmptyInputEmptyResultSuccess)
	TEST (SingleBuildStringGflagsCompatFlagTests, HasValueSuccess)
	TEST (BuildStringGflagsCompatFlagTests, EmptyInputEmptyResultSuccess)
	TEST (BuildStringGflagsCompatFlagTests, MultiValueSuccess)
	TEST (BuildStringGflagsCompatFlagTests, MultiEmptyValueSuccess)
	TEST (BuildStringGflagsCompatFlagTests, MultiValueMixedWithEmptySuccess)
std::string_view	format_as (SafeLevel level)
std::ostream &	operator<< (std::ostream &os, SafeLevel level)
template<typename Sink >
void	AbslStringify (Sink &sink, SafeLevel level)
Result< std::string >	DownloadFileWithBackup (BuildApi &build_api, const Build &build, const std::string &target_directory, const std::string &artifact_name, const std::string &backup_artifact_name)
Result< ReadableZip >	OpenZip (BuildApi &build_api, const Build &build, const std::string &name)
void	AppendBuildInfoToInvocationId (const DeviceBuild &build, std::vector< std::string > &cas_flags)
std::string	ConstructBuildDesc (const std::string &build_id, const std::string &build_target)
	TEST_F (CasDownloaderTests, FailsToCreateWithInvalidConfigPath)
	TEST_F (CasDownloaderTests, FailsToCreateWithInvalidCasDownloaderPath)
	TEST_F (CasDownloaderTests, UsesAdcIfServiceAccountUnavailable)
	TEST_F (CasDownloaderTests, UsesServiceAccountIfAvailable)
	TEST_F (CasDownloaderTests, IgnoresUnsupportedFlags)
	TEST_F (CasDownloaderTests, HandlesFalseBoolFlag)
	TEST_F (CasDownloaderTests, HandlesInvocationIdFlag)
	TEST_F (CasDownloaderTests, HandlesUnexpectedHelpOutput)
	TEST_F (CasDownloaderTests, PassesOptionalStatsFilepathWhenSet)
	TEST_F (CasDownloaderTests, RecognizesValidFlags)
	TEST_F (CasDownloaderTests, DisablesCacheIfCacheDirNotSet)
	TEST_F (CasDownloaderTests, CacheEnabledIfCacheDirSet)
	TEST_F (CasDownloaderTests, FailsIfDigestsFileDoesNotExist)
	TEST_F (CasDownloaderTests, FailsIfArtifactNotInDigestsFile)
	TEST_F (CasDownloaderTests, DownloadsDigestsOnlyIfNeeded)
	TEST_F (CasDownloaderTests, DownloadsUncompressedIfPreferUncompressed)
	TEST_F (CasDownloaderTests, DownloadsCompressedIfNotPreferUncompressed)
	TEST_F (CasDownloaderTests, DownloadsCompressedIfPreferUncompressedButUnavailable)
	TEST_F (CasDownloaderTests, PassesCasOptionsFromCommandLine)
	TEST_F (CasDownloaderTests, CacheMaxSize_DefaultWhenAbsent)
	TEST_F (CasDownloaderTests, CacheMaxSize_OverriddenWhenTooSmall)
int	main (int argc, char **argv)
	TEST_F (CasFlagsTests, DefaultValuesAreSet)
	TEST_F (CasFlagsTests, FlagsMethodReturnsVector)
	TEST_F (CasFlagsTests, MultipleInstancesIndependent)
	TEST_F (CasFlagsTests, FlagValueInitializesWithDefault)
	TEST_F (CasFlagsTests, FlagValueCanBeModified)
	TEST_F (CasFlagsTests, FlagValueConversion)
	TEST_F (CasFlagsTests, FlagValueComparisons)
	TEST_F (CasFlagsTests, FlagValuePointerLike)
	TEST_F (CasFlagsTests, PriorityLogicCliOverridesDefaults)
	TEST_F (CasFlagsTests, PriorityLogicConfigAppliesWhenNotCli)
	TEST_F (CasFlagsTests, PriorityLogicCliBlocksConfig)
std::ostream &	operator<< (std::ostream &stream, const ChromeOsBuilder &cob)
static Result< ChromeOsBuildString >	ParseChromeOsBuildString (const std::string &build_string)
std::ostream &	operator<< (std::ostream &stream, const ChromeOsBuildString &cb)
std::ostream &	operator<< (std::ostream &stream, const std::optional< ChromeOsBuildString > &cb)
Flag	GflagsCompatFlag (const std::string &name, std::vector< std::optional< ChromeOsBuildString > > &value)
std::unique_ptr< HttpClient >	CurlHttpClient (bool use_logging_debug_function)
	TEST (FakeHttpClientTest, WithoutUrlMatching)
	TEST (FakeHttpClientTest, NoMatchingUrl)
	TEST (FakeHttpClientTest, ChoosesUrl)
	TEST (FakeHttpClientTest, InvokesCallback)
std::optional< std::string_view >	HeaderValue (const std::vector< HttpHeader > &headers, std::string_view header_name)
Result< HttpResponse< std::string > >	HttpGetToFile (HttpClient &http_client, const std::string &url, const std::string &path, const std::vector< std::string > &headers)
Result< HttpResponse< Json::Value > >	HttpPostToJson (HttpClient &http_client, const std::string &url, const std::string &data, const std::vector< std::string > &headers)
Result< HttpResponse< Json::Value > >	HttpPostToJson (HttpClient &http_client, const std::string &url, const Json::Value &data, const std::vector< std::string > &headers)
Result< HttpResponse< Json::Value > >	HttpGetToJson (HttpClient &http_client, const std::string &url, const std::vector< std::string > &headers)
Result< HttpResponse< std::string > >	HttpGetToString (HttpClient &http_client, const std::string &url, const std::vector< std::string > &headers)
Result< HttpResponse< std::string > >	HttpPostToString (HttpClient &http_client, const std::string &url, const std::string &data, const std::vector< std::string > &headers)
std::unique_ptr< HttpClient >	RetryingServerErrorHttpClient (HttpClient &inner, int retry_attempts, std::chrono::milliseconds retry_delay)
std::string	ScrubSecrets (const std::string &data)
std::string	ScrubUrl (std::string_view url)
std::string	UrlEscape (std::string_view text)
bool	IsPopulated (const Oauth2ConsentRequest &request)
Result< std::unique_ptr< CredentialSource > >	Oauth2Login (HttpClient &http_client, const Oauth2ConsentRequest &request)
Result< std::unique_ptr< CredentialSource > >	CredentialForScopes (HttpClient &http_client, const std::vector< std::string > &scopes)
Result< std::vector< std::string > >	GetCvdCredentialFilepaths ()
Result< std::chrono::system_clock::time_point >	ParseTime (std::string_view str)
Result< SeekableZipSource >	BufferZipSource (std::unique_ptr< ReaderSeeker > data_provider, size_t buffer_size)
Result< SeekableZipSource >	BufferZipSource (SeekableZipSource source, size_t buffer_size)
Result< SeekableZipSource >	CacheZipSource (SeekableZipSource inner, std::string file_path)
ManagedZipError	NewZipError ()
std::string	ZipErrorString (zip_error_t *error)
std::string	ZipErrorString (zip_source_t *source)
std::string	ZipErrorString (zip_t *source)
int64_t	HandleCallback (ReadableZipSourceCallback &callbacks, zip_error_t *error, void *data, uint64_t len, zip_source_cmd_t cmd)
Result< std::unique_ptr< ReaderSeeker > >	ZipSourceAsReaderSeeker (SeekableZipSource inner)
Result< SeekableZipSource >	ZipSourceFromUrl (HttpClient &http_client, const std::string &url, std::vector< std::string > headers)
Result< ReadableZip >	ZipOpenRead (const std::string &fs_path)
Result< WritableZip >	ZipOpenReadWrite (const std::string &fs_path)
Result< void >	AddFile (WritableZip &zip, const std::string &fs_path)
Result< void >	AddFileAt (WritableZip &zip, const std::string &fs_path, const std::string &zip_path)
Result< void >	ExtractFile (ReadableZip &zip, std::string_view zip_path, const std::string &host_path)
Result< std::string >	ReadToString (ReadableZipSource &source)
Result< void >	AddStringAt (WritableZip &zip, const std::string &data, const std::string &zip_path)
Result< void >	Copy (Reader &reader, Writer &writer, const size_t buffer_size)
Result< void >	SparseCopy (Reader &reader, WriterSeeker &writer, size_t buffer_size)
Result< uint64_t >	FakePRead (ReaderSeeker &reader_seeker, void *buf, uint64_t count, uint64_t offset)
Result< uint64_t >	FakePWrite (WriterSeeker &writer_seeker, const void *buf, uint64_t count, uint64_t offset)
std::unique_ptr< ReaderWriterSeeker >	InMemoryIo ()
std::unique_ptr< ReaderWriterSeeker >	InMemoryIo (std::string_view str)
std::unique_ptr< ReaderWriterSeeker >	InMemoryIo (std::vector< char > data)
std::unique_ptr< ReadWriteFilesystem >	InMemoryFilesystem ()
	TEST (InMemoryIoTest, WriteSeek)
	TEST (InMemoryIoTest, WriteSeekRead)
	TEST (InMemoryIoTest, WriteAtReadAt)
	TEST (InMemoryIoTest, WriteWriteReadAt)
Result< uint64_t >	Length (Seeker &seeker)
Result< uint64_t >	Length (ReaderWriterSeeker &seeker)
Result< std::unique_ptr< Reader > >	Lz4LegacyReader (std::unique_ptr< Reader > source)
Result< std::unique_ptr< Writer > >	Lz4LegacyWriter (std::unique_ptr< Writer > sink)
Result< void >	ReadExact (Reader &reader, char *buf, size_t size)
Result< void >	PReadExact (const ReaderSeeker &reader, char *buf, size_t size, uint64_t offset)
Result< bool >	ReadExactOrEof (Reader &reader, char *buf, size_t size)
template<typename T >
Result< T >	ReadExactBinary (Reader &reader)
template<typename T >
Result< T >	PReadExactBinary (const ReaderSeeker &reader, uint64_t offset)
template<typename T >
Result< std::optional< T > >	ReadExactBinaryOrEof (Reader &reader)
std::string	Serialize (const DisjointRangeSet &range_set)
Result< DisjointRangeSet >	DeserializeDisjointRangeSet (std::string_view data)
Result< std::string >	ReadToString (Reader &reader, size_t buffer_size)
Result< void >	WriteExact (Writer &writer, const char *buf, size_t size)
Result< void >	WriteExact (Writer &writer, const char *buf)
Result< void >	WriteExact (Writer &writer, const std::string &str)
Result< void >	WriteExact (Writer &writer, const std::string_view str)
Result< void >	WriteExact (Writer &writer, const std::vector< char > &vec)
template<typename T >
Result< void >	WriteExactBinary (Writer &writer, const T &data)
void	PopulateCuttlefishFetch (MetricsEventV2 &event, const FetchMetrics &fetch_metrics)
void	PopulateCuttlefishGuest (MetricsEventV2 &metrics_event, const GuestMetrics &guest_metrics, std::string_view session_id)
void	PopulateCuttlefishHost (MetricsEventV2 &metrics_event, const HostMetrics &host_metrics)
CuttlefishLogEvent	BuildCuttlefishLogEvent (const MetricsData &metrics_data)
void	GatherVmInstantiationMetrics (const LocalInstanceGroup &instance_group)
void	GatherVmStartMetrics (const LocalInstanceGroup &instance_group)
void	GatherVmBootCompleteMetrics (const LocalInstanceGroup &instance_group)
void	GatherVmBootFailedMetrics (const LocalInstanceGroup &instance_group)
void	GatherVmStopMetrics (const LocalInstanceGroup &instance_group)
std::string	ToEventLabel (const FetchMetrics &fetch_metrics)
Result< FetchMetrics >	GetFetchMetrics (const FetchInput &fetch_input)
void	GatherFetchStartMetrics (const FetchFlags &fetch_flags)
void	GatherFetchCompleteMetrics (const std::string &target_directory, const FetchResult &fetch_result)
void	GatherFetchFailedMetrics (const std::string &target_directory)
std::string	DeviceEventTypeString (DeviceEventType event_type)
Result< FlagMetrics >	GetFlagMetrics (const ParsedFlags &parsed_flags, const int guest_index)
Result< std::vector< GuestMetrics > >	GetGuestMetrics (const Guests &guests)
Result< ParsedFlags >	GetParsedFlags ()
Result< std::optional< GceEnvironment > >	DetectGceEnvironment ()
std::optional< GitHubRepository >	DetectGitHubRepository ()
Result< HostMetrics >	GetHostMetrics ()
Invoker	GetInvoker ()
std::string	TransmitterPath ()
bool	AreMetricsEnabled ()
std::string	EnvironmentToString (ClearcutEnvironment environment)
Result< void >	TransmitMetrics (const std::string &transmitter_binary, const CuttlefishLogEvent &cf_log_event)
Result< void >	TransmitMetrics (const std::string &transmitter_binary, const logs::proto::wireless::android::cuttlefish::CuttlefishLogEvent &cf_log_event)
Result< void >	WriteMetricsEvent (std::string_view event_type_label, std::string_view metrics_directory, const CuttlefishLogEvent &cf_log_event)
Result< void >	WriteMetricsEvent (std::string_view event_type_label, std::string_view metrics_directory, const logs::proto::wireless::android::cuttlefish::CuttlefishLogEvent &cf_log_event)
void	DisplayPrivacyNotice ()
Result< std::string >	ReadSessionIdFile (const std::string &metrics_directory)
Result< void >	GenerateSessionIdFile (const std::string &metrics_directory)
Result< void >	SetUpMetrics (const std::string &metrics_directory)
ScopedLogger	CreateLogger (std::string_view metrics_directory)
Result< MetricsData >	GatherMetrics (const MetricsInput &metrics_input)
Result< void >	OutputMetrics (std::string_view event_type_label, std::string_view metrics_directory, const MetricsData &metrics_data)
Result< std::string >	GetSerializedEventProto (const std::string &event_filepath)
LogRequest	BuildLogRequest (const std::string &serialized_cf_log_event)
Result< MetricsFlags >	ProcessFlags (int argc, char **argv)
Result< void >	TransmitMetricsEvent (const wireless_android_play_playlog::LogRequest &log_request, ClearcutEnvironment environment)
Result< std::string >	ReadLink (const char *path)
Result< std::string >	ReadLink (const std::string &path)
Result< std::string >	ReadLink (std::string_view path)
Result< std::string >	RealPath (const std::string &path)
Result< void >	RemoveFile (const char *file)
Result< void >	RemoveFile (const std::string &file)
Result< void >	RemoveFile (std::string_view file)
Result< void >	Rename (const char *oldpath, const char *newpath)
Result< void >	Rename (const std::string &oldpath, const std::string &newpath)
Result< void >	Rename (std::string_view oldpath, std::string_view newpath)
Result< struct stat >	Stat (const char *path)
Result< struct stat >	Stat (const std::string &path)
Result< struct stat >	Stat (std::string_view path)
std::string	StrError (int error_num)
Result< void >	Symlink (const std::string &target, const std::string &linkpath)
std::ostream &	operator<< (std::ostream &out, const PrettyContainerType &pc)
std::string	format_as (const PrettyContainerType &pc)
template<typename Iterator , typename FmtIteratorFn >
PrettyContainerType	PrettyIterable (Iterator begin, Iterator end, FmtIteratorFn format_iterator_fn)
template<typename Iterator , typename FmtIteratorFn >
PrettyContainerType	PrettyIterable (Iterator begin, Iterator end)
template<typename T , typename FmtMemberFn >
PrettyContainerType	PrettyContainer (const T &container, FmtMemberFn format_member_fn)
template<typename T >
PrettyContainerType	PrettyContainer (const T &container)
	TEST (PrettyContainer, Empty)
	TEST (PrettyContainer, OneMember)
	TEST (PrettyContainer, StringMember)
	TEST (PrettyContainer, TwoMembers)
	TEST (PrettyContainer, MembersWithNewlines)
	TEST (PrettyContainer, NestedMember)
std::string	Pretty (const Json::Value &root, PrettyAdlPlaceholder)
	TEST (PrettyJson, Structured)
PrettyStruct	Pretty (const Extent &extent, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const LinearExtent &linear_extent, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const ZeroExtent &zero_extent, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const PartitionGroup &partition_group, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const Partition &partition, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const Interval &interval, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const android::fs_mgr::Extent &, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
PrettyStruct	Pretty (const android::fs_mgr::LinearExtent &, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
PrettyStruct	Pretty (const android::fs_mgr::ZeroExtent &, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
PrettyStruct	Pretty (const android::fs_mgr::PartitionGroup &, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
PrettyStruct	Pretty (const android::fs_mgr::Partition &, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
PrettyStruct	Pretty (const android::fs_mgr::Interval &, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
PrettyStruct	Pretty (const android::fs_mgr::LpMetadata &metadata, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const LpMetadataGeometry &geometry, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const LpMetadataTableDescriptor &metadata_table_descriptor, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const LpMetadataHeader &metadata_header, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const LpMetadataPartition &metadata_partition, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const LpMetadataExtent &metadata_extent, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const LpMetadataPartitionGroup &metadata_partition_group, PrettyAdlPlaceholder)
PrettyStruct	Pretty (const LpMetadataBlockDevice &block_device, PrettyAdlPlaceholder)
template<typename K , typename V , typename Compare >
PrettyContainerType	Pretty (const std::map< K, V, Compare > &map, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
int8_t	Pretty (int8_t value, PrettyAdlPlaceholder)
int16_t	Pretty (int16_t value, PrettyAdlPlaceholder)
int32_t	Pretty (int32_t value, PrettyAdlPlaceholder)
int64_t	Pretty (int64_t value, PrettyAdlPlaceholder)
uint8_t	Pretty (uint8_t value, PrettyAdlPlaceholder)
uint16_t	Pretty (uint16_t value, PrettyAdlPlaceholder)
uint32_t	Pretty (uint32_t value, PrettyAdlPlaceholder)
uint64_t	Pretty (uint64_t value, PrettyAdlPlaceholder)
char	Pretty (char value, PrettyAdlPlaceholder)
template<typename T >
std::string	Pretty (const std::optional< T > &value, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
template<typename First , typename Second >
PrettyStruct	Pretty (const std::pair< First, Second > &pair, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
template<typename T >
const T &	Pretty (const T &value, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
	TEST (Pretty, OuterInnerStruct)
template<typename T >
std::string	Pretty (const Result< T > &result, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
template<typename T , typename Comp >
PrettyContainerType	Pretty (const std::set< T, Comp > &set, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
std::string	Pretty (const std::string_view &value, PrettyAdlPlaceholder)
std::string	Pretty (const char *const &value, PrettyAdlPlaceholder)
std::string	Pretty (const std::string &value, PrettyAdlPlaceholder)
std::ostream &	operator<< (std::ostream &out, const PrettyStruct &ps)
std::string	format_as (const PrettyStruct &ps)
	TEST (PrettyStruct, Empty)
	TEST (PrettyStruct, OneMember)
	TEST (PrettyStruct, StringMember)
	TEST (PrettyStruct, TwoMembers)
	TEST (PrettyStruct, NestedMembers)
template<typename T >
std::string	Pretty (const std::unique_ptr< T > &value, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
template<typename T >
PrettyContainerType	Pretty (const std::vector< T > &vec, PrettyAdlPlaceholder unused=PrettyAdlPlaceholder())
std::ostream &	operator<< (std::ostream &out, const Command &command)
std::unordered_map< std::string, std::string >	EnvpToMap (char **envp)
int	Execute (std::vector< std::string > command)
Result< siginfo_t >	Execute (std::vector< std::string > command, SubprocessOptions subprocess_options, int wait_options)
int	RunWithManagedStdio (Command cmd_tmp, const std::string *stdin_str, std::string *stdout_str, std::string *stderr_str, SubprocessOptions options)
Result< std::string >	RunAndCaptureStdout (Command command)
static Result< uid_t >	FileOwnerUid (const std::string &file_path)
static Result< ProcStatusUids >	OwnerUids (const pid_t pid)
static std::string	PidDirPath (const pid_t pid)
static Result< std::string >	ReadAll (const std::string &file_path)
Result< std::vector< pid_t > >	CollectPids (const uid_t uid)
Result< std::vector< std::string > >	GetCmdArgs (const pid_t pid)
Result< std::string >	GetExecutablePath (const pid_t pid)
static Result< void >	CheckExecNameFromStatus (const std::string &exec_name, const pid_t pid)
Result< std::vector< pid_t > >	CollectPidsByExecName (const std::string &exec_name, const uid_t uid)
Result< std::vector< pid_t > >	CollectPidsByExecPath (const std::string &exec_path, const uid_t uid)
Result< std::vector< pid_t > >	CollectPidsByArgv0 (const std::string &expected_argv0, const uid_t uid)
Result< uid_t >	OwnerUid (const pid_t pid)
Result< std::unordered_map< std::string, std::string > >	GetEnvs (const pid_t pid)
Result< ProcInfo >	ExtractProcInfo (const pid_t pid)
Result< pid_t >	Ppid (const pid_t pid)
	TEST (ProcFileUid, SelfUidTest)
	TEST (ProcFilePid, CurrentPidCollected)
static Result< void >	SendSignalImpl (const int signal, const pid_t pid, bool to_group, const bool started)
StopperResult	KillSubprocess (Subprocess *subprocess)
SubprocessStopper	KillSubprocessFallback (std::function< StopperResult()> nice)
SubprocessStopper	KillSubprocessFallback (SubprocessStopper nice_stopper)
std::string	ResultErrorFormat (bool color)
std::ostream &	operator<< (std::ostream &out, const StackTraceError &error)
template<typename T >
T	OutcomeDereference (std::optional< T > &&value)
void	OutcomeDereference (Result< void > &&)
template<typename T >
T	OutcomeDereference (Result< T > &&result)
template<typename T >
std::enable_if< std::is_convertible_v< T, bool >, T >::type	OutcomeDereference (T &&value)
bool	TypeIsSuccess (bool value)
template<typename T >
bool	TypeIsSuccess (std::optional< T > &value)
template<typename T >
bool	TypeIsSuccess (Result< T > &value)
auto	ErrorFromType (bool)
template<typename T >
auto	ErrorFromType (std::optional< T >)
template<typename T >
auto	ErrorFromType (Result< T > &value)
	MATCHER (IsOk, "an ok result")
	MATCHER (IsError, "an error result")
	MATCHER_P (IsOkAndValue, result_value_matcher, "")
	MATCHER_P (IsErrorAndMessage, message_matcher, "")
	TEST (ResultTest, ExpectBoolGoodNoMessage)
	TEST (ResultTest, ExpectBoolGoodWithMessage)
	TEST (ResultTest, ExpectBoolBadNoMessage)
	TEST (ResultTest, ExpectBoolBadWithMessage)
	TEST (ResultTest, ExpectWithResultGoodNoMessage)
	TEST (ResultTest, ExpectWithResultGoodWithMessage)
	TEST (ResultTest, ExpectWithResultBadNoMessage)
	TEST (ResultTest, ExpectWithResultBadWithMessage)
	TEST (ResultTest, ExpectEqGoodNoMessage)
	TEST (ResultTest, ExpectEqGoodWithMessage)
	TEST (ResultTest, ExpectEqBadNoMessage)
	TEST (ResultTest, ExpectEqBadWithMessage)

Variables
constexpr char	kCvdNetworkGroupName [] = "cvdnetwork"
constexpr char	kWirelessIp [] = "192.168.96"
constexpr char	kMobileIp [] = "192.168.97"
constexpr char	kEthernetIp [] = "192.168.98"
constexpr int	kSocketMode = 0666
constexpr uint32_t	kMaxIfaceNameId = 63
constexpr std::string_view	kAnsiCursorTopLeft = "\033[;H"
constexpr std::string_view	kAnsiBoldBlue = "\033[1;34m"
constexpr std::string_view	kAnsiBoldCyan = "\033[1;36m"
constexpr std::string_view	kAnsiClearScreen = "\033[2J"
constexpr std::string_view	kAnsiClearScreenAfterCursor = "\033[J"
constexpr std::string_view	kAnsiCsi = "\033["
constexpr std::string_view	kAnsiCyan = "\033[0;36m"
constexpr std::string_view	kAnsiGreen = "\033[0;32m"
constexpr std::string_view	kAnsiGrey = "\033[90m"
constexpr std::string_view	kAnsiRed = "\033[0;31m"
constexpr std::string_view	kAnsiReset = "\033[0m"
constexpr std::string_view	kAnsiWhite = "\033[0;37m"
constexpr std::string_view	kAnsiYellow = "\033[0;33m"
constexpr std::string_view	kXtermUseAlternateScreen = "\033[?1049h"
constexpr std::string_view	kXtermUseMainScreen = "\033[?1049l"
char	pipe_message [] = "Testing the pipe"
constexpr int	DISK_SIZE_SHIFT = 16
constexpr int	PARTITION_SIZE_SHIFT = 12
constexpr const char *	kConsoleSeverityEnvVar = "CF_CONSOLE_SEVERITY"
constexpr const char *	kFileSeverityEnvVar = "CF_FILE_SEVERITY"
constexpr std::string_view	kDefaultInterfacePrefix = "cvd"
constexpr uint32_t	kBootImagePageSize = 4096
static constexpr char	kImageName [] = "chromeos_state.img"
static constexpr int	kImageSizeMb = 8096
static constexpr std::string_view	kName = "android_esp"
static constexpr size_t	kMetadataImageMb = 64
static constexpr size_t	kMetadataImageBytes = kMetadataImageMb << 20
constexpr char	kDefaultsFilePath []
constexpr size_t	kDefaultCacheSizeGb = 25
constexpr char	kFleetSubcmd [] = "fleet"
constexpr char	kSummaryHelpText []
static constexpr char	kHelpMessage []
constexpr size_t	kDefaultMaxLineWidth = 80
constexpr size_t	kCvdRetainLogFilesNum = 30
constexpr char	kFlagModemSimulatorSimType [] = "modem_simulator_sim_type"
static constexpr std::string_view	kPhoneInstanceTemplate
static constexpr std::string_view	kTabletInstanceTemplate
static constexpr std::string_view	kTvInstanceTemplate
static constexpr std::string_view	kWearableInstanceTemplate
static constexpr std::string_view	kAutoInstanceTemplate
static constexpr std::string_view	kSlimInstanceTemplate
static constexpr std::string_view	kGoInstanceTemplate
static constexpr std::string_view	kFoldableInstanceTemplate
constexpr char	kAndroidBuildApiScope []
constexpr char	kCloudStorageReadScope []
constexpr char	kDefaultApiKey [] = ""
constexpr char	kDefaultCredentialSource [] = ""
constexpr char	kDefaultProjectID [] = ""
constexpr std::chrono::seconds	kDefaultWaitRetryPeriod
constexpr bool	kDefaultEnableCaching = true
constexpr bool	kDefaultUseGceMetadata = false
constexpr char	kDefaultCredentialFilepath [] = ""
constexpr char	kDefaultServiceAccountFilepath [] = ""
static constexpr mode_t	kRwxAllMode = S_IRWXU | S_IRWXG | S_IRWXO
constexpr char	kDefaultBuildString [] = ""
constexpr char	kDefaultTargetDirectory [] = ""
constexpr bool	kDefaultKeepDownloadedArchives = false
constexpr char	kDefaultBuildTarget []
constexpr char	kTargetDirectory [] = "--target_directory=/tmp/fetch_test"
constexpr char	kDefaultBuild []
constexpr char	kCasDownloaderPath []
constexpr char	kCasCacheDir [] = "--cas_cache_dir=/tmp/cas_cache"
constexpr char	kCasCacheMaxSize [] = "--cas_cache_max_size=10000000000"
static constexpr char	kHostToolsSubdirectory [] = "host_tools"
constexpr bool	kDefaultDownloadImgZip = true
constexpr bool	kDefaultDownloadTargetFilesZip = false
constexpr bool	kDefaultDynamicSuperImageFragments = false
constexpr char	kDefaultOPeratorControlSocketPath []
static constexpr char	kCvdMarkEnv [] = "_STARTED_BY_CVD_SERVER_"
constexpr char	kServerExecPath [] = "/proc/self/exe"
constexpr char	kAndroidHostOut [] = "ANDROID_HOST_OUT"
constexpr char	kAndroidSoongHostOut [] = "ANDROID_SOONG_HOST_OUT"
constexpr char	kAndroidProductOut [] = "ANDROID_PRODUCT_OUT"
char	kEmptyText []
char	kEmptyRteTrkText []
char	kValidText []
char	kNullAttributeText []
char	kLocationMissingLongitudeLatitudeText []
char	kLocationMissingLongitudeText []
char	kValidLocationText []
char	kValidDocumentText []
char	kEmptyKmlText []
char	kValidkmlText []
char	kValidComplexText []
char	kOneCoordinateText []
char	kMultipleCoordinatesText []
char	kBadCoordinatesText []
char	kLocationNormalText []
char	kLocationMissingFieldsText []
char	kLocationMissingRequiredFieldsText []
char	kLocationNameOnlyFirstText []
char	kMultipleLocationsText []
char	kTraverseEmptyDocText []
char	kNoPlacemarksText []
char	kNestedDocText []
char	kNullNameNoCrashText []
constexpr std::string_view	kCvdallocInterfacePrefix = "cvd-pi"
constexpr std::string_view	kCvdallocEthernetBridgeName = "cvd-pi-ebr"
constexpr std::string_view	kCvdallocWirelessBridgeName = "cvd-pi-wbr"
constexpr char	kCvdallocMobileIpPrefix [] = "192.168.144"
constexpr char	kCvdallocWirelessIpPrefix [] = "192.168.160"
constexpr char	kCvdallocWirelessApIpPrefix [] = "192.168.176"
constexpr char	kCvdallocEthernetIpPrefix [] = "192.168.192"
static constexpr char	kUsageMessage []
constexpr int32_t	kMaxCommandLength = 4096
static const std::string	kAreaCode = "2142"
static const std::string	kCellId = "0000B804"
constexpr int	kRssiUnknownValue = 99
constexpr int	kBerUnknownValue = 99
constexpr int	kDbmUnknownValue = -1
constexpr int	kEcioUnknownValue = -1
constexpr int	kSnrUnknownValue = -1
constexpr auto	kRssiRange = std::make_pair(4, 30)
constexpr auto	kDbmRange = std::make_pair(-120, -4)
constexpr auto	kRsrpRange = std::make_pair(-140, -44)
static constexpr char	kInstances [] = "instances"
static constexpr char	kNetworkSelectionMode [] = "network_selection_mode"
static constexpr char	kOperatorNumeric [] = "operator_numeric"
static constexpr char	kModemTechnoloy [] = "modem_technoloy"
static constexpr char	kPreferredNetworkMode [] = "preferred_network_mode"
static constexpr char	kEmergencyMode [] = "emergency_mode"
static constexpr int	kDefaultNetworkSelectionMode = 0
static constexpr int	kDefaultModemTechnoloy = ModemTechnology::M_MODEM_TECH_LTE
static constexpr int	kDefaultPreferredNetworkMode
static constexpr bool	kDefaultEmergencyMode = false
static const std::string	kWithoutServiceCenterAddress = "00"
static const std::string	kStatusReportIndicator = "06"
static const std::string	kSRIAndMMSIndicator = "24"
static const std::string	kUDHIAndSRIAndMMSIndicator = "64"
constexpr int	kSimPukSize = 8
constexpr int	kSimPinMaxRetryTimes = 3
constexpr int	kSimPukMaxRetryTimes = 10
static const std::string	kDefaultPinCode = "1234"
static const std::string	kDefaultPukCode = "12345678"
static const std::string	MF_SIM = "3F00"
static const std::string	DF_TELECOM = "7F10"
static const std::string	DF_PHONEBOOK = "5F3A"
static const std::string	DF_GRAPHICS = "5F50"
static const std::string	DF_GSM = "7F20"
static const std::string	DF_CDMA = "7F25"
static const std::string	DF_ADF = "7FFF"
constexpr int	kFooterSizeBytes = 14
constexpr int	kMaxNumberSizeBytes = 11
constexpr int	kMaxLogicalChannels = 3
const std::map< SimService::SimStatus, std::string >	gSimStatusResponse
static constexpr char	kIgnoreSigtstpHelp []
static constexpr char	kWhenDumpedHelp [] = "restart when the process crashed"
static constexpr char	kWhenKilledHelp [] = "restart when the process was killed"
static constexpr char	kWhenExitedWithFailureHelp []
static constexpr char	kWhenExitedWithCodeHelp []
static constexpr char	kHelp []
template<class... >
constexpr std::false_type	CommandAlwaysFalse {}
constexpr std::chrono::seconds	kCvdAllocateTimeout = std::chrono::seconds(30)
constexpr std::chrono::seconds	kCvdTeardownTimeout = std::chrono::seconds(2)
static constexpr uint32_t	BLOCK_SIZE = 16
static constexpr char	kUniqueKey [] = "JsonSerializable"
static constexpr char	kUniqueKey [] = "TpmKeyBlobMaker"
static int	MAX_STIR_RANDOM_BUFFER_SIZE = 128
template<typename T >
int	MarshalFn = 0
template<typename T >
int	UnmarshalFn = 0
template<>
auto	MarshalFn< TPM2B_PRIVATE > = Tss2_MU_TPM2B_PRIVATE_Marshal
template<>
auto	UnmarshalFn< TPM2B_PRIVATE > = Tss2_MU_TPM2B_PRIVATE_Unmarshal
template<>
auto	MarshalFn< TPM2B_PUBLIC > = Tss2_MU_TPM2B_PUBLIC_Marshal
template<>
auto	UnmarshalFn< TPM2B_PUBLIC > = Tss2_MU_TPM2B_PUBLIC_Unmarshal
static std::unordered_set< std::string >	kRepeatableFlags
static uint64_t	num_tombstones_in_last_second = 0
static std::string	last_tombstone_name = ""
static constexpr size_t	CHUNK_RECV_MAX_LEN = 1024
static constexpr size_t	TIMEOUT_SEC = 3
static const std::array< uint16_t, 17 >	kJsIndexToLinuxMapping
constexpr auto	kOpewnrtWanIpAddressName = "wan_ipaddr"
constexpr auto	kTouchscreenPrefix = "display_"
constexpr auto	kTouchpadPrefix = "touch_"
constexpr uint8_t	VIRTIO_SND_CHMAP_MAX_SIZE = 18
constexpr uint32_t	VIOS_VERSION = 3
constexpr uint64_t	kMaxAvbMetadataSize = 69632ul
constexpr const char	kMetaInfoJsonFileName [] = "snapshot_meta_info.json"
constexpr const char	kGuestSnapshotField [] = "guest_snapshot"
constexpr const char	kSnapshotPathField [] = "snapshot_path"
constexpr const char	kCfHomeField [] = "HOME"
constexpr const char	kGuestSnapshotBase [] = "guest_vm"
constexpr char	kLogcatSerialMode [] = "serial"
constexpr char	kLogcatVsockMode [] = "vsock"
constexpr char	kDefaultUuidPrefix []
constexpr char	kCuttlefishConfigEnvVarName [] = "CUTTLEFISH_CONFIG_FILE"
constexpr char	kCuttlefishInstanceEnvVarName [] = "CUTTLEFISH_INSTANCE"
constexpr char	kVsocUserPrefix [] = "vsoc-"
constexpr char	kInternalGroupName [] = "cvd"
constexpr char	kCvdNamePrefix [] = "cvd-"
constexpr char	kBootStartedMessage [] = "VIRTUAL_DEVICE_BOOT_STARTED"
constexpr char	kBootPendingMessage [] = "VIRTUAL_DEVICE_BOOT_PENDING"
constexpr char	kBootCompletedMessage [] = "VIRTUAL_DEVICE_BOOT_COMPLETED"
constexpr char	kBootFailedMessage [] = "VIRTUAL_DEVICE_BOOT_FAILED"
constexpr char	kMobileNetworkConnectedMessage []
constexpr char	kWifiConnectedMessage []
constexpr char	kEthernetConnectedMessage []
constexpr char	kAdbdStartedMessage []
constexpr char	kFastbootdStartedMessage []
constexpr char	kHibernationExitMessage []
constexpr char	kFastbootStartedMessage []
constexpr char	kGblFastbootStartedMessage []
constexpr char	kScreenChangedMessage [] = "VIRTUAL_DEVICE_SCREEN_CHANGED"
constexpr char	kDisplayPowerModeChangedMessage []
constexpr char	kInternalDirName [] = "internal"
constexpr char	kGrpcSocketDirName [] = "grpc_socket"
constexpr char	kSharedDirName [] = "shared"
constexpr char	kLogDirName [] = "logs"
constexpr char	kCrosvmVarEmptyDir [] = "/var/empty"
constexpr char	kKernelLoadedMessage [] = "] Linux version"
constexpr char	kBootloaderLoadedMessage [] = "U-Boot 20"
constexpr char	kApName [] = "crosvm_openwrt"
constexpr int	kDefaultInstance = 1
constexpr char	kVhostUserVsockModeAuto [] = "auto"
constexpr char	kVhostUserVsockModeTrue [] = "true"
constexpr char	kVhostUserVsockModeFalse [] = "false"
constexpr char	kGpuVhostUserModeAuto [] = "auto"
constexpr char	kGpuVhostUserModeOn [] = "on"
constexpr char	kGpuVhostUserModeOff [] = "off"
constexpr char	kHwComposerAuto [] = "auto"
constexpr char	kHwComposerDrm [] = "drm_hwcomposer"
constexpr char	kHwComposerRanchu [] = "ranchu"
constexpr char	kHwComposerNone [] = "none"
static constexpr char	kFragments [] = "fragments"
static constexpr char	kRootDir [] = "root_dir"
static constexpr char	kVmManager [] = "vm_manager"
static constexpr char	kApVmManager [] = "ap_vm_manager"
static constexpr char	kSecureHals [] = "secure_hals"
static constexpr char	kCrosvmBinary [] = "crosvm_binary"
static constexpr char	kGem5DebugFlags [] = "gem5_debug_flags"
static constexpr char	kSigServerPort [] = "webrtc_sig_server_port"
static constexpr char	kSigServerAddress [] = "webrtc_sig_server_addr"
static constexpr char	kHostToolsVersion [] = "host_tools_version"
static constexpr char	kEnableHostUwb [] = "enable_host_uwb"
static constexpr char	kPicaUciPort [] = "pica_uci_port"
static constexpr char	kEnableAutomotiveProxy [] = "enable_automotive_proxy"
static constexpr char	kEnableHostNfc [] = "enable_host_nfc"
static constexpr char	kEnableHostNfcConnector [] = "enable_host_nfc_connector"
static constexpr char	kCasimirInstanceNum [] = "casimir_instance_num"
static constexpr char	kCasimirArgs [] = "casimir_args"
static constexpr char	kCasimirNciPort [] = "casimir_nci_port"
static constexpr char	kCasimirRfPort [] = "casimir_rf_port"
static constexpr char	kNetsimInstanceNum [] = "netsim_instance_num"
static constexpr char	kNetsimConnectorInstanceNum []
static constexpr char	kNetsimArgs [] = "netsim_args"
static constexpr char	kExtraKernelCmdline [] = "extra_kernel_cmdline"
static constexpr char	kVirtioMac80211Hwsim [] = "virtio_mac80211_hwsim"
static constexpr char	kApRootfsImage [] = "ap_rootfs_image"
static constexpr char	kApKernelImage [] = "ap_kernel_image"
static constexpr char	kRootcanalArgs [] = "rootcanal_args"
static constexpr char	kRootcanalHciPort [] = "rootcanal_hci_port"
static constexpr char	kRootcanalLinkPort [] = "rootcanal_link_port"
static constexpr char	kRootcanalLinkBlePort [] = "rootcanal_link_ble_port"
static constexpr char	kRootcanalTestPort [] = "rootcanal_test_port"
static constexpr char	kSnapshotPath [] = "snapshot_path"
static constexpr char	kKvmPath [] = "kvm_path"
static constexpr char	kVhostVsockPath [] = "vhost_vsock_path"
static constexpr char	kStracedExecutables [] = "straced_host_executables"
static constexpr char	kInstancesUdsDir [] = "instances_uds_dir"
static constexpr char	kEnvironmentsUdsDir [] = "environments_uds_dir"
static constexpr char	kInstanceNames [] = "instance_names"
static constexpr char	kEnableWifi [] = "enable_wifi"
static constexpr char	kStartWmediumd [] = "start_wmediumd"
static constexpr char	kVhostUserMac80211Hwsim [] = "vhost_user_mac80211_hwsim"
static constexpr char	kWmediumdApiServerSocket [] = "wmediumd_api_server_socket"
static constexpr char	kWmediumdConfig [] = "wmediumd_config"
static constexpr char	kWmediumdMacPrefix [] = "wmediumd_mac_prefix"
static constexpr char	kGroupUuid [] = "group_uuid"
static constexpr char	kInstanceDir [] = "instance_dir"
static constexpr char	kImagesDir [] = "images_dir"
static constexpr char	kInitBootImage [] = "init_boot_image"
static constexpr char	kDataImage [] = "data_image"
static constexpr char	kNewDataImage [] = "new_data_image"
static constexpr char	kSuperImage [] = "super_image"
static constexpr char	kNewSuperImage [] = "new_super_image"
static constexpr char	kVendorBootImage [] = "vendor_boot_image"
static constexpr char	kNewVendorBootImage [] = "new_vendor_boot_image"
static constexpr char	kVbmetaImage [] = "vbmeta_image"
static constexpr char	kNewVbmetaImage [] = "new_vbmeta_image"
static constexpr char	kVbmetaSystemImage [] = "vbmeta_system_image"
static constexpr char	kVbmetaVendorDlkmImage [] = "vbmeta_vendor_dlkm_image"
static constexpr char	kNewVbmetaVendorDlkmImage []
static constexpr char	kVbmetaSystemDlkmImage [] = "vbmeta_system_dlkm_image"
static constexpr char	kNewVbmetaSystemDlkmImage []
static constexpr char	kOtherosEspImage [] = "otheros_esp_image"
static constexpr char	kAndroidEfiLoader [] = "android_efi_loader"
static constexpr char	kChromeOsDisk [] = "chromeos_disk"
static constexpr char	kChromeOsKernelPath [] = "chromeos_kernel_path"
static constexpr char	kChromeOsRootImage [] = "chromeos_root_image"
static constexpr char	kLinuxKernelPath [] = "linux_kernel_path"
static constexpr char	kLinuxInitramfsPath [] = "linux_initramfs_path"
static constexpr char	kLinuxRootImage [] = "linux_root_image"
static constexpr char	kFuchsiaZedbootPath [] = "fuchsia_zedboot_path"
static constexpr char	kFuchsiaMultibootBinPath [] = "multiboot_bin_path"
static constexpr char	kFuchsiaRootImage [] = "fuchsia_root_image"
static constexpr char	kCustomPartitionPath [] = "custom_partition_path"
static constexpr char	kBlankSdcardImageMb [] = "blank_sdcard_image_mb"
static constexpr char	kBootloader [] = "bootloader"
static constexpr char	kInitramfsPath [] = "initramfs_path"
static constexpr char	kKernelPath [] = "kernel_path"
static constexpr char	kVvmtruststorePath [] = "vvmtruststore_path"
static constexpr char	kDefaultTargetZip [] = "default_target_zip"
static constexpr char	kSystemTargetZip [] = "system_target_zip"
static constexpr char	kSerialNumber [] = "serial_number"
static constexpr char	kVirtualDiskPaths [] = "virtual_disk_paths"
static constexpr char	kGuestAndroidVersion [] = "guest_android_version"
static constexpr char	kBootconfigSupported [] = "bootconfig_supported"
static constexpr char	kFilenameEncryptionMode [] = "filename_encryption_mode"
static constexpr char	kExternalNetworkMode [] = "external_network_mode"
static constexpr char	kGnssGrpcProxyServerPort []
static constexpr char	kGnssFilePath [] = "gnss_file_path"
static constexpr char	kFixedLocationFilePath [] = "fixed_location_file_path"
static constexpr char	kGem5BinaryDir [] = "gem5_binary_dir"
static constexpr char	kGem5CheckpointDir [] = "gem5_checkpoint_dir"
static constexpr char	kKgdb [] = "kgdb"
static constexpr char	kCpus [] = "cpus"
static constexpr char	kVcpuInfo [] = "vcpu_config_path"
static constexpr char	kDataPolicy [] = "data_policy"
static constexpr char	kBlankDataImageMb [] = "blank_data_image_mb"
static constexpr char	kGdbPort [] = "gdb_port"
static constexpr char	kMemoryMb [] = "memory_mb"
static constexpr char	kDdrMemMb [] = "ddr_mem_mb"
static constexpr char	kSetupWizardMode [] = "setupwizard_mode"
static constexpr char	kUserdataFormat [] = "userdata_format"
static constexpr char	kGuestEnforceSecurity [] = "guest_enforce_security"
static constexpr char	kUseSdcard [] = "use_sdcard"
static constexpr char	kPauseInBootloader [] = "pause_in_bootloader"
static constexpr char	kRunAsDaemon [] = "run_as_daemon"
static constexpr char	kEnableMinimalMode [] = "enable_minimal_mode"
static constexpr char	kRunModemSimulator [] = "enable_modem_simulator"
static constexpr char	kModemSimulatorInstanceNumber []
static constexpr char	kModemSimulatorSimType [] = "modem_simulator_sim_type"
static constexpr char	kGpuMode [] = "gpu_mode"
static constexpr char	kGpuModeCandidates [] = "gpu_mode_candidates"
static constexpr char	kGpuAngleFeatureOverridesEnabled []
static constexpr char	kGpuAngleFeatureOverridesDisabled []
static constexpr char	kGpuCaptureBinary [] = "gpu_capture_binary"
static constexpr char	kGpuGfxstreamTransport [] = "gpu_gfxstream_transport"
static constexpr char	kGpuRendererFeatures [] = "gpu_renderer_features"
static constexpr char	kGpuContextTypes [] = "gpu_context_types"
static constexpr char	kGuestHwuiRenderer [] = "guest_hwui_renderer"
static constexpr char	kGuestRendererPreload [] = "guest_renderer_preload"
static constexpr char	kVulkanDriver [] = "guest_vulkan_driver"
static constexpr char	kGuestUsesBgraFramebuffers []
static constexpr char	kRestartSubprocesses [] = "restart_subprocesses"
static constexpr char	kHWComposer [] = "hwcomposer"
static constexpr char	kEnableGpuUdmabuf [] = "enable_gpu_udmabuf"
static constexpr char	kEnableGpuVhostUser [] = "enable_gpu_vhost_user"
static constexpr char	kEnableGpuExternalBlob [] = "enable_gpu_external_blob"
static constexpr char	kEnableGpuSystemBlob [] = "enable_gpu_system_blob"
static constexpr char	kHasVulkanGfxstreamApex [] = "has_vulkan_gfxstream_apex"
static constexpr char	kHasVulkanLavapipeApex [] = "has_vulkan_lavapipe_apex"
static constexpr char	kHasVulkanSwiftshaderApex []
static constexpr char	kEnableAudio [] = "enable_audio"
static constexpr char	kEnableMouse [] = "enable_mouse"
static constexpr char	kEnableGamepad [] = "enable_gamepad"
static constexpr char	kCustomKeyboardConfig [] = "custom_keyboard_config"
static constexpr char	kDomkeyMappingConfig [] = "domkey_mapping_config"
static constexpr char	kEnableGnssGrpcProxy [] = "enable_gnss_grpc_proxy"
static constexpr char	kEnableBootAnimation [] = "enable_bootanimation"
static constexpr char	kEnableUsb [] = "enable_usb"
static constexpr char	kExtraBootconfigArgsInstanced [] = "extra_bootconfig_args"
static constexpr char	kRecordScreen [] = "record_screen"
static constexpr char	kGem5DebugFile [] = "gem5_debug_file"
static constexpr char	kMte [] = "mte"
static constexpr char	kEnableKernelLog [] = "enable_kernel_log"
static constexpr char	kBootSlot [] = "boot_slot"
static constexpr char	kFailFast [] = "fail_fast"
static constexpr char	kVhostUserBlock [] = "vhost_user_block"
static constexpr char	kTi50 [] = "ti50"
static constexpr char	kEnableJcardSimulator [] = "enable_jcard_simulator"
static constexpr char	kWebRTCAssetsDir [] = "webrtc_assets_dir"
static constexpr char	kWebrtcTcpPortRange [] = "webrtc_tcp_port_range"
static constexpr char	kWebrtcUdpPortRange [] = "webrtc_udp_port_range"
static constexpr char	kGrpcConfig [] = "grpc_config"
static constexpr char	kSmt [] = "smt"
static constexpr char	kCrosvmBinary [] = "crosvm_binary"
static constexpr char	kSeccompPolicyDir [] = "seccomp_policy_dir"
static constexpr char	kQemuBinaryDir [] = "qemu_binary_dir"
static constexpr char	kVhostNet [] = "vhost_net"
static constexpr char	kOpenThreadNodeId [] = "openthread_node_id"
static constexpr char	kVhostUserVsock [] = "vhost_user_vsock"
static constexpr char	kRilDns [] = "ril_dns"
static constexpr char	kRilIpaddr [] = "ril_ipaddr"
static constexpr char	kRilGateway [] = "ril_gateway"
static constexpr char	kRilBroadcast [] = "ril_broadcast"
static constexpr char	kRilPrefixlen [] = "ril_prefixlen"
static constexpr char	kDisplayConfigs [] = "display_configs"
static constexpr char	kXRes [] = "x_res"
static constexpr char	kYRes [] = "y_res"
static constexpr char	kDpi [] = "dpi"
static constexpr char	kRefreshRateHz [] = "refresh_rate_hz"
static constexpr char	kOverlays [] = "overlays"
static constexpr char	kTouchpadConfigs [] = "touchpad_configs"
static constexpr char	kTargetArch [] = "target_arch"
static constexpr char	kDeviceType [] = "device_type"
static constexpr char	kEnableSandbox [] = "enable_sandbox"
static constexpr char	kEnableVirtiofs [] = "enable_virtiofs"
static constexpr char	kConsole [] = "console"
static constexpr char	kModemSimulatorPorts [] = "modem_simulator_ports"
static constexpr char	kEnableModemNetsim [] = "enable_modem_netsim"
static constexpr char	kMobileBridgeName [] = "mobile_bridge_name"
static constexpr char	kMobileTapName [] = "mobile_tap_name"
static constexpr char	kMobileMac [] = "mobile_mac"
static constexpr char	kWifiTapName [] = "wifi_tap_name"
static constexpr char	kHasWifi [] = "has_wifi_card"
static constexpr char	kWifiBridgeName [] = "wifi_bridge_name"
static constexpr char	kWifiMac [] = "wifi_mac"
static constexpr char	kUseBridgedWifiTap [] = "use_bridged_wifi_tap"
static constexpr char	kEthernetTapName [] = "ethernet_tap_name"
static constexpr char	kEthernetBridgeName [] = "ethernet_bridge_name"
static constexpr char	kEthernetMac [] = "ethernet_mac"
static constexpr char	kEthernetIPV6 [] = "ethernet_ipv6"
static constexpr char	kHasBluetooth [] = "has_bluetooth"
static constexpr char	kRequiresHostBluetoothConnector []
static constexpr char	kEnableHostUwbConnector [] = "enable_host_uwb_connector"
static constexpr char	kUseCvdalloc [] = "use_cvdalloc"
static constexpr char	kSessionId [] = "session_id"
static constexpr char	kVsockGuestCid [] = "vsock_guest_cid"
static constexpr char	kVsockGuestGroup [] = "vsock_guest_group"
static constexpr char	kUuid [] = "uuid"
static constexpr char	kEnvironmentName [] = "environment_name"
static constexpr char	kHostPort [] = "adb_host_port"
static constexpr char	kFastbootHostPort [] = "fastboot_host_port"
static constexpr char	kModemSimulatorId [] = "modem_simulator_host_id"
static constexpr char	kAdbIPAndPort [] = "adb_ip_and_port"
static constexpr char	kQemuVncServerPort [] = "qemu_vnc_server_port"
static constexpr char	kTombstoneReceiverPort [] = "tombstone_receiver_port"
static constexpr char	kAudioControlServerPort [] = "audiocontrol_server_port"
static constexpr char	kLightsServerPort [] = "lights_server_port"
static constexpr char	kCameraServerPort [] = "camera_server_port"
static constexpr char	kWebrtcDeviceId [] = "webrtc_device_id"
static constexpr char	kStartRootcanal [] = "start_rootcanal"
static constexpr char	kStartCasimir [] = "start_casimir"
static constexpr char	kStartPica [] = "start_pica"
static constexpr char	kStartNetsim [] = "start_netsim"
static constexpr char	kStartWmediumdInstance [] = "start_wmediumd_instance"
static constexpr char	kMcu [] = "mcu"
static constexpr char	kApBootFlow [] = "ap_boot_flow"
static constexpr char	kCrosvmUseBalloon [] = "crosvm_use_balloon"
static constexpr char	kCrosvmUseRng [] = "crosvm_use_rng"
static constexpr char	kCrosvmSimpleMediaDevice [] = "crosvm_simple_media_device"
static constexpr char	kCrosvmV4l2Proxy [] = "crosvm_v4l2_proxy"
static constexpr char	kCrosvmUsePmem [] = "use_pmem"
static constexpr char	kEnablePkvm [] = "enable_pkvm"
static constexpr char	kCrosvmAcpiTable [] = "crosvm_acpi_table"
static constexpr char	kCrosvmDeviceTreeOverlay [] = "crosvm_device_tree_overlay"
static constexpr char	kCrosvmFileBackedMapping [] = "crosvm_file_backed_mapping"
static constexpr char	kEnableTapDevices [] = "enable_tap_devices"
static constexpr char	kFrameSockPath [] = "frame_sock_path"
static constexpr char	kWifiMacPrefix [] = "wifi_mac_prefix"
static constexpr char	kEnableVhalProxyServer [] = "enable_vhal_proxy_server"
static constexpr char	kVhalProxyServerPort [] = "vhal_proxy_server_port"
static constexpr char	kAudioOutputStreamsCount [] = "audio_output_streams_count"
static constexpr char	kAudioSettingsTextProto [] = "audio_settings_textproto"
static constexpr char	kMediaConfigs [] = "media_configs"
static constexpr char	kMediaType [] = "type"
static constexpr char	kMediaLensFacing [] = "lens_facing"
static constexpr char	kMediaInputPath [] = "input_path"
static constexpr char	kMediaInputWidth [] = "input_width"
static constexpr char	kMediaInputHeight [] = "input_height"
static constexpr char	kMediaInputFps [] = "input_fps"
constexpr const char	kDisplayFlag [] = "display"
constexpr const char	kDisplayHelp []
static constexpr char	kBootSrcPathX64 []
static constexpr char	kBootDestPathX64 [] = "/EFI/BOOT/BOOTX64.EFI"
static constexpr char	kBootSrcPathAA64 []
static constexpr char	kBootDestPathAA64 [] = "/EFI/BOOT/BOOTAA64.EFI"
static constexpr char	kBootDestPathRiscV64 [] = "/EFI/BOOT/BOOTRISCV64.EFI"
static constexpr char	kMultibootModuleSrcPathX64 []
static constexpr char	kMultibootModuleSrcPathAA64 []
static constexpr char	kMultibootModuleDestPath [] = "/EFI/modules/multiboot.mod"
static constexpr char	kKernelDestPath [] = "/vmlinuz"
static constexpr char	kInitrdDestPath [] = "/initrd"
static constexpr char	kZedbootDestPath [] = "/zedboot.zbi"
static constexpr char	kMultibootBinDestPath [] = "/multiboot.bin"
static constexpr char	kGrubDebianConfigDestPath [] = "/EFI/debian/grub.cfg"
static constexpr char	kGrubUbuntuConfigDestPath [] = "/EFI/ubuntu/grub.cfg"
static constexpr char	kGrubConfigDestDirectoryPath [] = "/boot/grub"
static constexpr char	kGrubConfigDestPath [] = "/boot/grub/grub.cfg"
static constexpr std::array	kGrubModules
static constexpr char	kGrubModulesPath [] = "/usr/lib/grub"
static constexpr char	kGrubModulesX64Name [] = "x86_64-efi"
static constexpr std::string_view	kFetcherConfigFile = "fetcher_config.json"
constexpr std::string_view	kGpuModeAuto = "auto"
constexpr std::string_view	kGpuModeCustom = "custom"
constexpr std::string_view	kGpuModeDrmVirgl = "drm_virgl"
constexpr std::string_view	kGpuModeGfxstream = "gfxstream"
constexpr std::string_view	kGpuModeGfxstreamGuestAngle
constexpr std::string_view	kGpuModeGfxstreamGuestAngleHostLavapipe
constexpr std::string_view	kGpuModeGfxstreamGuestAngleHostSwiftshader
constexpr std::string_view	kGpuModeGuestLavapipe = "guest_lavapipe"
constexpr std::string_view	kGpuModeGuestSwiftshader
constexpr std::string_view	kGpuModeNone = "none"
static constexpr char	kMediaTypeV4l2EmulatedCameraSPlane []
static constexpr char	kMediaTypeV4l2EmulatedCameraMPlane []
static constexpr char	kMediaTypeV4l2Proxy [] = "v4l2_proxy"
static constexpr char	kMediaTypeV4l2Stream [] = "v4l2_stream_proxy"
constexpr const char	kMediaFlag [] = "media"
constexpr const char	kMediaHelp []
static constexpr uint8_t	kPadValue = 0xff
static constexpr uint32_t	kCrcSize = sizeof(uint32_t)
static constexpr size_t	kNullPadLength = 1
constexpr const char	kTouchpadFlag [] = "touchpad"
constexpr const char	kTouchpadHelp []
constexpr int	GPT_NUM_PARTITIONS = 128
constexpr int	kSectorSizeShift = 9
constexpr int	kSectorSize = 1 << kSectorSizeShift
constexpr char	kLogNameAssembleCvd [] = "assemble_cvd.log"
constexpr char	kLogNameBuildInfo [] = "build_info.log"
constexpr char	kLogNameCrosvmOpenWrt [] = "crosvm_openwrt.log"
constexpr char	kLogNameCrosvmOpenWrtBoot [] = "crosvm_openwrt_boot.log"
constexpr char	kLogNameFetch [] = "fetch.log"
constexpr char	kLogNameKernel [] = "kernel.log"
constexpr char	kLogNameLauncher [] = "launcher.log"
constexpr char	kLogNameLogcat [] = "logcat"
constexpr char	kLogNameMetrics [] = "metrics.log"
constexpr char	kLogNameMetricsV2 [] = "metrics_v2.log"
constexpr char	kLogNameModemSimulator [] = "modem_simulator.log"
constexpr SafeLevel	kAllSafeLevels []
constexpr char	kAndroidBuildServiceUrl []
constexpr char	kKeyDownloaderPath [] = "downloader-path"
constexpr char	kKeyFlags [] = "flags"
constexpr char	kFlagDigest [] = "digest"
constexpr char	kFlagDir [] = "dir"
constexpr char	kFlagDumpJson [] = "dump-json"
constexpr char	kFlagDisableCache [] = "disable-cache"
constexpr char	kFlagCasInstance [] = "cas-instance"
constexpr char	kFlagCasAddr [] = "cas-addr"
constexpr char	kFlagServiceAccountJson [] = "service-account-json"
constexpr char	kFlagUseAdc [] = "use-adc"
constexpr int	kDefaultMemoryLimit = 0
constexpr int	kDefaultCasConcurrency = 500
constexpr int	kDefaultRpcTimeout = 120
constexpr int	kDefaultGetCapabilitiesTimeout = 5
constexpr int	kDefaultGetTreeTimeout = 5
constexpr int	kDefaultBatchReadBlobsTimeout = 180
constexpr int	kDefaultBatchUpdateBlobsTimeout = 60
constexpr int64_t	kMinCacheMaxSize = 8LL * 1024 * 1024 * 1024
constexpr const char	kDefaultCasConfigFilePath []
constexpr const char	kDefaultDownloaderPath [] = "/usr/bin/casdownloader"
static constexpr size_t	kBufferSize = 1 << 26
static constexpr size_t	kMinReadSize = 1 << 26
constexpr uint32_t	kLz4LegacyFrameBlockSize = 8 << 20
constexpr char	kTransmitterPath []
constexpr std::string_view	kClearcutLocal = "local"
constexpr std::string_view	kClearcutStaging = "staging"
constexpr std::string_view	kClearcutProduction = "production"
static constexpr char	kProcDir [] = "/proc"

Detailed Description

Classes to to enable safe access to files. POSIX kernels have an unfortunate habit of recycling file descriptors. That can cause problems like http://b/26121457 in code that doesn't manage file lifetimes properly. These classes implement an alternate interface that has some advantages:

o References to files are tightly controlled o Files are auto-closed if they go out of scope o Files are life-time aware. It is impossible to close the instance twice. o File descriptors are always initialized. By default the descriptor is set to a closed instance.

These classes are designed to mimic to POSIX interface as closely as possible. Specifically, they don't attempt to track the type of file descriptors and expose only the valid operations. This is by design, since it makes it easier to convert existing code to SharedFDs and avoids the possibility that new POSIX functionality will lead to large refactorings.

ConfUiUserSelectionMessage with a security flag

Inputs generated by something that belong to (virtualized) TEE is regarded as secure. Otherwise (e.g. inputs generated by the guest calling deliverSecureInputEvent), it is regarded as insecure.

The host marks the security field, and use it internally and exclusively.

Functions for manipulating disk files given to crosvm or QEMU.

Typedef Documentation

AutoCmd

template<auto Fn>

using cuttlefish::AutoCmd = typedef GenericCommandImpl<Fn, decltype(Fn)>

AutoDiagnostic

template<auto Fn>

using cuttlefish::AutoDiagnostic = typedef DiagnosticInformationFnImpl<Fn, decltype(Fn)>

AutoSensorsSocketPair

using cuttlefish::AutoSensorsSocketPair = typedef AutoSetup<SensorsSocketPair::Create>

AutoSetup

template<auto Fn>

using cuttlefish::AutoSetup = typedef GenericSetupImpl<Fn, decltype(Fn)>

AutoSnapshotControlFiles

using cuttlefish::AutoSnapshotControlFiles = typedef AutoSetup<SnapshotControlFiles::Create>

Build

using cuttlefish::Build = typedef std::variant<DeviceBuild, DirectoryBuild>

BuildString

using cuttlefish::BuildString = typedef std::variant<DeviceBuildString, DirectoryBuildString>

ChromeOsBuildString

using cuttlefish::ChromeOsBuildString = typedef std::variant<ChromeOsBuilder, std::string>

CvdServerClock

using cuttlefish::CvdServerClock = typedef std::chrono::system_clock

DigestsFetcher

using cuttlefish::DigestsFetcher = typedef std::function<Result<std::string>(std::string)>

Environment

using cuttlefish::Environment = typedef std::variant<GceEnvironment, GitHubRepository, UnknownEnvironment>

f_func

using cuttlefish::f_func = typedef std::function<void(const Client&)>

FetchInput

using cuttlefish::FetchInput = typedef std::variant<FetchFlags, FetchResult>

FetchMetrics

using cuttlefish::FetchMetrics = typedef std::variant<FetchStartMetrics, FetchCompleteMetrics, FetchFailedMetrics>

GenerateProcessedFrameCallbackImpl

using cuttlefish::GenerateProcessedFrameCallbackImpl = typedef std::function<void(uint32_t , uint32_t , uint32_t , uint32_t , uint32_t , uint8_t* )>

InterruptListener

using cuttlefish::InterruptListener = typedef std::function<void(int)>

ManagedZip

using cuttlefish::ManagedZip = typedef std::unique_ptr<zip_t, ZipDeleter>

ManagedZipError

using cuttlefish::ManagedZipError = typedef std::unique_ptr<zip_error_t, ZipDeleter>

ManagedZipSource

using cuttlefish::ManagedZipSource = typedef std::unique_ptr<zip_source_t, ZipDeleter>

MiscInfo

using cuttlefish::MiscInfo = typedef std::map<std::string, std::string, std::less<void> >

NvencEncoderHandle

using cuttlefish::NvencEncoderHandle = typedef std::unique_ptr<void, NvencEncoderDeleter>

OnConsumedCb

using cuttlefish::OnConsumedCb = typedef std::function<void(AudioStatus, uint32_t , uint32_t )>

p_func

using cuttlefish::p_func = typedef std::function<void(const Client&, std::string&)>

PsRow

using cuttlefish::PsRow = typedef std::map<PsColumns, std::string>

Result

template<typename T >

using cuttlefish::Result = typedef tl::expected<T, StackTraceError>

Result is comparable to std::expected in C++23, or Rust's Result type, but specialized to use a specific error type. The error type tracks a stack trace of the failure that is built as a failure unrolls the call stack.

SerializeTpmKeyPrivate

using cuttlefish::SerializeTpmKeyPrivate = typedef TpmSerializable<TPM2B_PRIVATE>

SerializeTpmKeyPublic

using cuttlefish::SerializeTpmKeyPublic = typedef TpmSerializable<TPM2B_PUBLIC>

SubprocessStopper

using cuttlefish::SubprocessStopper = typedef std::function<StopperResult(Subprocess*)>

TimeStamp

using cuttlefish::TimeStamp = typedef std::chrono::time_point<CvdServerClock>

TpmObjectSlot

using cuttlefish::TpmObjectSlot = typedef std::shared_ptr<TpmResourceManager::ObjectSlot>

TxBuffer

using cuttlefish::TxBuffer = typedef ShmBuffer

UniqueEsysPtr

template<typename T >

using cuttlefish::UniqueEsysPtr = typedef std::unique_ptr<T, EsysDeleter>

WalkDirectoryCallback

using cuttlefish::WalkDirectoryCallback = typedef std::function<Result<void>(const std::string&)>

Enumeration Type Documentation

AdbMode

enum class cuttlefish::AdbMode

strong

Enumerator
VsockTunnel
VsockHalfTunnel
NativeVsock
Unknown

APBootFlow

enum class cuttlefish::APBootFlow

strong

Enumerator
None
Grub
LegacyDirect

Arch

enum class cuttlefish::Arch

strong

Enumerator
Arm
Arm64
RiscV64
X86
X86_64

AudioChannelMap

enum cuttlefish::AudioChannelMap : uint8_t

Enumerator
VIRTIO_SND_CHMAP_NONE
VIRTIO_SND_CHMAP_NA
VIRTIO_SND_CHMAP_MONO
VIRTIO_SND_CHMAP_FL
VIRTIO_SND_CHMAP_FR
VIRTIO_SND_CHMAP_RL
VIRTIO_SND_CHMAP_RR
VIRTIO_SND_CHMAP_FC
VIRTIO_SND_CHMAP_LFE
VIRTIO_SND_CHMAP_SL
VIRTIO_SND_CHMAP_SR
VIRTIO_SND_CHMAP_RC
VIRTIO_SND_CHMAP_FLC
VIRTIO_SND_CHMAP_FRC
VIRTIO_SND_CHMAP_RLC
VIRTIO_SND_CHMAP_RRC
VIRTIO_SND_CHMAP_FLW
VIRTIO_SND_CHMAP_FRW
VIRTIO_SND_CHMAP_FLH
VIRTIO_SND_CHMAP_FCH
VIRTIO_SND_CHMAP_FRH
VIRTIO_SND_CHMAP_TC
VIRTIO_SND_CHMAP_TFL
VIRTIO_SND_CHMAP_TFR
VIRTIO_SND_CHMAP_TFC
VIRTIO_SND_CHMAP_TRL
VIRTIO_SND_CHMAP_TRR
VIRTIO_SND_CHMAP_TRC
VIRTIO_SND_CHMAP_TFLC
VIRTIO_SND_CHMAP_TFRC
VIRTIO_SND_CHMAP_TSL
VIRTIO_SND_CHMAP_TSR
VIRTIO_SND_CHMAP_LLFE
VIRTIO_SND_CHMAP_RLFE
VIRTIO_SND_CHMAP_BC
VIRTIO_SND_CHMAP_BLC
VIRTIO_SND_CHMAP_BRC

AudioChannelsLayout

enum class cuttlefish::AudioChannelsLayout

strong

Enumerator
Mono
Stereo
Surround51

AudioCommandType

enum class cuttlefish::AudioCommandType : uint32_t

strong

Enumerator
VIRTIO_SND_R_JACK_INFO
VIRTIO_SND_R_JACK_REMAP
VIRTIO_SND_R_PCM_INFO
VIRTIO_SND_R_PCM_SET_PARAMS
VIRTIO_SND_R_PCM_PREPARE
VIRTIO_SND_R_PCM_RELEASE
VIRTIO_SND_R_PCM_START
VIRTIO_SND_R_PCM_STOP
VIRTIO_SND_R_CHMAP_INFO
VIRTIO_SND_R_CTL_INFO
VIRTIO_SND_R_CTL_ENUM_ITEMS
VIRTIO_SND_R_CTL_READ
VIRTIO_SND_R_CTL_WRITE
VIRTIO_SND_R_CTL_TLV_READ
VIRTIO_SND_R_CTL_TLV_WRITE
VIRTIO_SND_R_CTL_TLV_COMMAND

AudioControlAccess

enum cuttlefish::AudioControlAccess : uint8_t

Enumerator
VIRTIO_SND_CTL_ACCESS_READ
VIRTIO_SND_CTL_ACCESS_WRITE
VIRTIO_SND_CTL_ACCESS_VOLATILE
VIRTIO_SND_CTL_ACCESS_INACTIVE
VIRTIO_SND_CTL_ACCESS_TLV_READ
VIRTIO_SND_CTL_ACCESS_TLV_WRITE
VIRTIO_SND_CTL_ACCESS_TLV_COMMAND

AudioControlRole

enum class cuttlefish::AudioControlRole : uint8_t

strong

Enumerator
VIRTIO_SND_CTL_ROLE_UNDEFINED
VIRTIO_SND_CTL_ROLE_VOLUME
VIRTIO_SND_CTL_ROLE_MUTE
VIRTIO_SND_CTL_ROLE_GAIN

AudioControlType

enum class cuttlefish::AudioControlType : uint8_t

strong

Enumerator
VIRTIO_SND_CTL_TYPE_BOOLEAN
VIRTIO_SND_CTL_TYPE_INTEGER
VIRTIO_SND_CTL_TYPE_INTEGER64
VIRTIO_SND_CTL_TYPE_ENUMERATED
VIRTIO_SND_CTL_TYPE_BYTES
VIRTIO_SND_CTL_TYPE_IEC958

AudioJackFeatures

enum cuttlefish::AudioJackFeatures : uint8_t

Enumerator
VIRTIO_SND_JACK_F_REMAP

AudioStatus

enum class cuttlefish::AudioStatus : uint32_t

strong

Enumerator
VIRTIO_SND_S_OK
VIRTIO_SND_S_BAD_MSG
VIRTIO_SND_S_NOT_SUPP
VIRTIO_SND_S_IO_ERR
NOT_SET

AudioStreamDirection

enum class cuttlefish::AudioStreamDirection : uint8_t

strong

Enumerator
VIRTIO_SND_D_OUTPUT
VIRTIO_SND_D_INPUT

AudioStreamFormat

enum class cuttlefish::AudioStreamFormat : uint8_t

strong

Enumerator
VIRTIO_SND_PCM_FMT_IMA_ADPCM
VIRTIO_SND_PCM_FMT_MU_LAW
VIRTIO_SND_PCM_FMT_A_LAW
VIRTIO_SND_PCM_FMT_S8
VIRTIO_SND_PCM_FMT_U8
VIRTIO_SND_PCM_FMT_S16
VIRTIO_SND_PCM_FMT_U16
VIRTIO_SND_PCM_FMT_S18_3
VIRTIO_SND_PCM_FMT_U18_3
VIRTIO_SND_PCM_FMT_S20_3
VIRTIO_SND_PCM_FMT_U20_3
VIRTIO_SND_PCM_FMT_S24_3
VIRTIO_SND_PCM_FMT_U24_3
VIRTIO_SND_PCM_FMT_S20
VIRTIO_SND_PCM_FMT_U20
VIRTIO_SND_PCM_FMT_S24
VIRTIO_SND_PCM_FMT_U24
VIRTIO_SND_PCM_FMT_S32
VIRTIO_SND_PCM_FMT_U32
VIRTIO_SND_PCM_FMT_FLOAT
VIRTIO_SND_PCM_FMT_FLOAT64
VIRTIO_SND_PCM_FMT_DSD_U8
VIRTIO_SND_PCM_FMT_DSD_U16
VIRTIO_SND_PCM_FMT_DSD_U32
VIRTIO_SND_PCM_FMT_IEC958_SUBFRAME

AudioStreamRate

enum cuttlefish::AudioStreamRate : uint8_t

Enumerator
VIRTIO_SND_PCM_RATE_5512
VIRTIO_SND_PCM_RATE_8000
VIRTIO_SND_PCM_RATE_11025
VIRTIO_SND_PCM_RATE_16000
VIRTIO_SND_PCM_RATE_22050
VIRTIO_SND_PCM_RATE_32000
VIRTIO_SND_PCM_RATE_44100
VIRTIO_SND_PCM_RATE_48000
VIRTIO_SND_PCM_RATE_64000
VIRTIO_SND_PCM_RATE_88200
VIRTIO_SND_PCM_RATE_96000
VIRTIO_SND_PCM_RATE_176400
VIRTIO_SND_PCM_RATE_192000
VIRTIO_SND_PCM_RATE_384000

BootFlow

enum class cuttlefish::BootFlow

strong

Enumerator
Android
AndroidEfiLoader
ChromeOs
ChromeOsDisk
Linux
Fuchsia

ClearcutEnvironment

enum class cuttlefish::ClearcutEnvironment

strong

Enumerator
Local
Staging
Production

CoerceToNullopt

enum class cuttlefish::CoerceToNullopt

strong

Enumerator
None
UnsetKeyword
EmptyString

CvdallocStatus

enum class cuttlefish::CvdallocStatus

strong

Enumerator
kUnknown
kAvailable
kFailed

DataImagePolicy

enum class cuttlefish::DataImagePolicy

strong

Enumerator
AlwaysCreate
ResizeUpTo
Unknown
UseExisting

DeviceEventType

enum class cuttlefish::DeviceEventType

strong

Enumerator
DeviceInstantiation
DeviceBootStart
DeviceBootComplete
DeviceStop
DeviceBootFailed

DeviceType

enum class cuttlefish::DeviceType

strong

Enumerator
Unknown
Phone
Wear
Auto
Foldable
Tv
Minidroid
Go
Desktop

ExternalNetworkMode

enum class cuttlefish::ExternalNetworkMode

strong

Enumerator
kUnknown
kTap
kSlirp

FileSource

enum class cuttlefish::FileSource

strong

When a file is downloaded from cvd fetch, this is the "reason" the file is downloaded. More specifically, whether it corresponds to the --default_build argument, the --system_build argument, --kernel_build, et cetera.

Order in enum is not guaranteed to be stable, serialized as a string.

Enumerator
UNKNOWN_PURPOSE
DEFAULT_BUILD
SYSTEM_BUILD
KERNEL_BUILD
LOCAL_FILE
GENERATED
BOOTLOADER_BUILD
ANDROID_EFI_LOADER_BUILD
BOOT_BUILD
HOST_PACKAGE_BUILD
CHROME_OS_BUILD
TEST_SUITES_BUILD

GitHubRepository

enum class cuttlefish::GitHubRepository

strong

Enumerator
AndroidCuttlefish
CloudAndroidOrchestration
Unknown

GptPartitionType

enum class cuttlefish::GptPartitionType

strong

Enumerator
kLinuxFilesystem
kEfiSystemPartition

GpuMode

enum class cuttlefish::GpuMode

strong

Enumerator
Auto
Custom
DrmVirgl
Gfxstream
GfxstreamGuestAngle
GfxstreamGuestAngleHostLavapipe
GfxstreamGuestAngleHostSwiftshader
GuestLavapipe
GuestSwiftshader
None

GuestHwuiRenderer

enum class cuttlefish::GuestHwuiRenderer

strong

Enumerator
kUnknown
kSkiaGl
kSkiaVk

GuestOs

enum class cuttlefish::GuestOs

strong

Enumerator
Android
ChromeOs
Linux
Fuchsia

GuestRendererPreload

enum class cuttlefish::GuestRendererPreload

strong

Enumerator
kAuto
kGuestDefault
kEnabled
kDisabled

HttpMethod

enum class cuttlefish::HttpMethod

strong

Enumerator
kGet
kPost
kDelete
kHead

InstanceDirActionOnStop

enum class cuttlefish::InstanceDirActionOnStop

strong

Enumerator
Keep
Clear

InUseState

enum class cuttlefish::InUseState : char

strong

Enumerator
kInUse
kNotInUse

Invoker

enum class cuttlefish::Invoker

strong

Enumerator
Acloud
HostOrchestrator
None
Unknown

LauncherAction

enum class cuttlefish::LauncherAction : char

strong

Enumerator
kExtended	expect additional information to follow
kFail
kPowerwash
kRestart
kStatus
kStop

LauncherResponse

enum class cuttlefish::LauncherResponse : char

strong

Enumerator
kSuccess
kError
kUnknownAction

LogSeverity

enum class cuttlefish::LogSeverity : int

strong

Enumerator
Verbose
Debug
Info
Warning
Error
Fatal

MetadataLevel

enum class cuttlefish::MetadataLevel

strong

Enumerator
FULL
ONLY_MESSAGE
TAG_AND_MESSAGE

ModemServiceType

enum cuttlefish::ModemServiceType : int

Enumerator
kSimService
kNetworkService
kDataService
kCallService
kSmsService
kSupService
kStkService
kMiscService

ModemSimulatorExitCodes

enum cuttlefish::ModemSimulatorExitCodes : int

Enumerator
kSuccess
kSelectError
kServerError

ModemTechnology

enum cuttlefish::ModemTechnology

Enumerator
M_MODEM_TECH_GSM
M_MODEM_TECH_WCDMA
M_MODEM_TECH_CDMA
M_MODEM_TECH_EVDO
M_MODEM_TECH_TDSCDMA
M_MODEM_TECH_LTE
M_MODEM_TECH_NR

Os

enum class cuttlefish::Os

strong

Enumerator
Linux
Unknown

PsColumns

enum class cuttlefish::PsColumns

strong

Enumerator
kGroups
kNames
kId
kStatus
kCreated
kAdbSerial
kWebAccess

RunnerExitCodes

enum cuttlefish::RunnerExitCodes : int

Enumerator
kSuccess
kArgumentParsingError
kInvalidHostConfiguration
kCuttlefishConfigurationInitError
kInstanceDirCreationError
kPrioFilesCleanupError
kBootImageUnpackError
kCuttlefishConfigurationSaveError
kDaemonizationError
kVMCreationError
kPipeIOError
kVirtualDeviceBootFailed
kProcessGroupError
kMonitorCreationFailed
kServerError
kUsbV1SocketError
kE2eTestFailed
kKernelDecompressError
kLogcatServerError
kConfigServerError
kTombstoneServerError
kTombstoneDirCreationError
kInitRamFsConcatError
kTapDeviceInUse
kTpmPassthroughError
kModemSimulatorServerError
kSocketProxyServerError

SafeLevel

enum class cuttlefish::SafeLevel

strong

Enumerator
kSafeLevelUnspecified
kSafe0
kSafe1
kSafe2
kPlatinum

SecureHal

enum class cuttlefish::SecureHal

strong

Enumerator
kGuestGatekeeperInsecure
kGuestKeymintInsecure
kGuestKeymintTrustyInsecure
kGuestStrongboxInsecure
kHostKeymintInsecure
kHostKeymintSecure
kHostGatekeeperInsecure
kHostGatekeeperSecure
kHostOemlockInsecure
kHostOemlockSecure
kHostWeaverSecure

SnapshotCmd

enum class cuttlefish::SnapshotCmd : int

strong

Enumerator
kUnknown
kSuspend
kResume
kSnapshotTake

SnapshotSocketMessage

enum cuttlefish::SnapshotSocketMessage : uint8_t

Enumerator
kSuspend
kSuspendAck
kResume

Status

enum class cuttlefish::Status : uint32_t

strong

Enumerator
Ok
BadMessage
NotSupported
IOError

StopperResult

enum class cuttlefish::StopperResult

strong

Enumerator
kFailure
kCrash
kSuccess

VmmMode

enum class cuttlefish::VmmMode

strong

Enumerator
kUnknown
kCrosvm
kGem5
kQemu

ZipCompression

enum class cuttlefish::ZipCompression

strong

Enumerator
kDefault
kStore
kBzip2
kDeflate
kXz
kZstd

Function Documentation

__attribute__() [1/2]

struct cuttlefish::__attribute__

(

(__packed__)

)

__attribute__() [2/2]

struct cuttlefish::__attribute__

(

(packed)

)

AbslStringify() [1/6]

template<typename Sink >

void cuttlefish::AbslStringify	(	Sink &	sink,
		Arch	arch
	)

AbslStringify() [2/6]

template<typename Sink >

void cuttlefish::AbslStringify	(	Sink &	sink,
		DeviceType	device_type
	)

AbslStringify() [3/6]

template<typename Sink >

void cuttlefish::AbslStringify	(	Sink &	sink,
		FakeAndroidBuild::ImageStatus	image_status
	)

AbslStringify() [4/6]

template<typename Sink >

void cuttlefish::AbslStringify	(	Sink &	sink,
		FileSource	file_source
	)

AbslStringify() [5/6]

template<typename Sink >

void cuttlefish::AbslStringify	(	Sink &	sink,
		GpuMode	mode
	)

AbslStringify() [6/6]

template<typename Sink >

void cuttlefish::AbslStringify	(	Sink &	sink,
		SafeLevel	level
	)

AbsolutePath()

std::string cuttlefish::AbsolutePath

(

std::string_view

path

)

AccessKregistryPath()

std::string cuttlefish::AccessKregistryPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

AdbConfigComponent()

fruit::Component< AdbConfig > cuttlefish::AdbConfigComponent

(

)

AdbConfigFlagComponent()

fruit::Component< fruit::Required< AdbConfig, ConfigFlag >, AdbConfigFlag > cuttlefish::AdbConfigFlagComponent

(

)

AdbConfigFragmentComponent()

fruit::Component< fruit::Required< AdbConfig >, AdbConfigFragment > cuttlefish::AdbConfigFragmentComponent

(

)

AdbConnectorBinary()

std::string cuttlefish::AdbConnectorBinary

(

)

AdbConnectorMain()

int cuttlefish::AdbConnectorMain	(	int	argc,
		char *	argv[]
	)

AdbModeToString()

std::string cuttlefish::AdbModeToString

(

AdbMode

mode

)

AddFile()

Result< void > cuttlefish::AddFile	(	WritableZip &	zip,
		const std::string &	fs_path
	)

AddFileAt()

Result< void > cuttlefish::AddFileAt	(	WritableZip &	zip,
		const std::string &	fs_path,
		const std::string &	zip_path
	)

AddGateway()

Result< void > cuttlefish::AddGateway	(	std::string_view	name,
		std::string_view	gateway,
		std::string_view	netmask
	)

AddGrubConfig()

EspBuilder cuttlefish::AddGrubConfig

(

const std::string &

config

)

AddStringAt()

Result< void > cuttlefish::AddStringAt	(	WritableZip &	zip,
		const std::string &	data,
		const std::string &	zip_path
	)

AddTapIface()

Result< void > cuttlefish::AddTapIface

(

std::string_view

name

)

AggregateImage()

Result< void > cuttlefish::AggregateImage	(	const std::vector< ImagePartition > &	partitions,
		const std::string &	output_path
	)

Combine the files in partition into a single raw disk file and write it to output_path. The raw disk file will have a GUID Partition Table and copy in the contents of the files mentioned in partitions.

AlignToPartitionSize()

uint64_t cuttlefish::AlignToPartitionSize

(

uint64_t

size

)

AlignToPowerOf2()

constexpr uint64_t cuttlefish::AlignToPowerOf2 ( uint64_t  val, uint8_t  align_log  )

constexpr

AllocateNetworkInterfaces()

std::optional< IfaceConfig > cuttlefish::AllocateNetworkInterfaces

(

)

alpha_blend_layer()

void cuttlefish::alpha_blend_layer	(	uint8_t *	frame_pixels,
		uint32_t	h,
		uint32_t	w,
		uint8_t *	overlay
	)

AndroidBuildFromMiscInfo()

Result< std::unique_ptr< AndroidBuild > > cuttlefish::AndroidBuildFromMiscInfo

(

std::map< std::string, std::string, std::less< void > >

)

Reports partition information from the key-value pairs in a misc_info.txt file.

Although misc_info.txt does not contain any image files, it does have a complete list of the logical partitions that are intended to be present in a complete super.img file, as well as the division between "system" and "vendor" side logical partitions.

AndroidCompositeDiskConfig()

Result< std::vector< ImagePartition > > cuttlefish::AndroidCompositeDiskConfig	(	const CuttlefishConfig::InstanceSpecific &	instance,
		const std::vector< std::unique_ptr< ImageFile > > &	image_files,
		AndroidBuild &	android_build,
		const SystemImageDirFlag &	system_image_dir
	)

AndroidDistBuild()

Result< std::unique_ptr< AndroidBuild > > cuttlefish::AndroidDistBuild

(

const std::string &

product_dir

)

AndroidHostPath()

Result< std::string > cuttlefish::AndroidHostPath

(

const std::unordered_map< std::string, std::string > &

envs

)

AndroidProductDir()

Result< std::unique_ptr< AndroidBuild > > cuttlefish::AndroidProductDir

(

std::string

path

)

AnsiCursorUp()

std::string cuttlefish::AnsiCursorUp

(

int

n

)

ApCompositeDiskBuilder()

DiskBuilder cuttlefish::ApCompositeDiskBuilder	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance
	)

AppendBuildInfoToInvocationId()

void cuttlefish::AppendBuildInfoToInvocationId	(	const DeviceBuild &	build,
		std::vector< std::string > &	cas_flags
	)

ArchiveContents()

std::vector< std::string > cuttlefish::ArchiveContents

(

const std::string &

archive

)

ArchToStringView()

std::string_view cuttlefish::ArchToStringView

(

Arch

arch

)

AreHardLinked()

Result< bool > cuttlefish::AreHardLinked	(	const std::string &	source,
		const std::string &	destination
	)

AreMetricsEnabled()

bool cuttlefish::AreMetricsEnabled

(

)

As() [1/5]

template<typename T >

Result< T > cuttlefish::As

(

const Json::Value &

v

)

As() [2/5]

template<>

Result< int > cuttlefish::As ( const Json::Value &  v )

inline

As() [3/5]

template<>

Result< std::string > cuttlefish::As ( const Json::Value &  v )

inline

As() [4/5]

template<>

Result< bool > cuttlefish::As ( const Json::Value &  v )

inline

As() [5/5]

template<>

Result< Json::Value > cuttlefish::As ( const Json::Value &  v )

inline

AssembleCvdMain()

Result< int > cuttlefish::AssembleCvdMain	(	int	argc,
		char **	argv
	)

AssemblyDirFromHome()

std::string cuttlefish::AssemblyDirFromHome

(

const std::string &

group_home_dir

)

ASSERT_VALID_MSG_TYPE() [1/11]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	IoStatusMsg	,
		16
	)

ASSERT_VALID_MSG_TYPE() [2/11]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	IoTransferMsg	,
		12
	)

ASSERT_VALID_MSG_TYPE() [3/11]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_chmap_info	,
		24
	)

ASSERT_VALID_MSG_TYPE() [4/11]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_ctl_hdr	,
		8
	)

ASSERT_VALID_MSG_TYPE() [5/11]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_ctl_info	,
		96
	)

ASSERT_VALID_MSG_TYPE() [6/11]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_ctl_value	,
		512
	)

ASSERT_VALID_MSG_TYPE() [7/11]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_jack_info	,
		24
	)

ASSERT_VALID_MSG_TYPE() [8/11]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_pcm_hdr	,
		8
	)

ASSERT_VALID_MSG_TYPE() [9/11]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_pcm_info	,
		32
	)

ASSERT_VALID_MSG_TYPE() [10/11]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_pcm_set_params	,
		24
	)

ASSERT_VALID_MSG_TYPE() [11/11]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_query_info	,
		16
	)

AssertProtoEquals()

static void cuttlefish::AssertProtoEquals ( const Message &  expected, const Message &  actual  )

static

AutomotiveProxyBinary()

std::string cuttlefish::AutomotiveProxyBinary

(

)

AutomotiveProxyService()

std::optional< MonitorCommand > cuttlefish::AutomotiveProxyService

(

const CuttlefishConfig &

config

)

AvailableFilesReport()

FetcherConfig cuttlefish::AvailableFilesReport

(

)

AvbToolBinary()

std::string cuttlefish::AvbToolBinary

(

)

BeginElevatedPrivileges()

int cuttlefish::BeginElevatedPrivileges

(

)

BluetoothConnector()

Result< std::optional< MonitorCommand > > cuttlefish::BluetoothConnector	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance
	)

BoolFromGlobalGflags() [1/2]

Result< FromGflags< bool > > cuttlefish::BoolFromGlobalGflags	(	const gflags::CommandLineFlagInfo &	flag_info,
		const std::string &	flag_name
	)

BoolFromGlobalGflags() [2/2]

Result< FromGflags< bool > > cuttlefish::BoolFromGlobalGflags	(	const gflags::CommandLineFlagInfo &	flag_info,
		const std::string &	flag_name,
		bool	default_value
	)

BootCfgArgs()

static Result< std::string > cuttlefish::BootCfgArgs ( const Instance &  instance )

static

BootconfigArgsFromConfig()

Result< std::unordered_map< std::string, std::string > > cuttlefish::BootconfigArgsFromConfig	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance,
		const std::map< std::string, std::string, std::less< void > >	builtin_bootconfig_args
	)

BootconfigArgsString()

Result< std::string > cuttlefish::BootconfigArgsString	(	const std::unordered_map< std::string, std::string > &	args,
		const std::string &	separator
	)

BootloaderPresentCheck()

Result< void > cuttlefish::BootloaderPresentCheck

(

const CuttlefishConfig::InstanceSpecific &

instance

)

bootStateMachineComponent()

fruit::Component< fruit::Required< const CuttlefishConfig, KernelLogPipeProvider, const CuttlefishConfig::InstanceSpecific, const vm_manager::VmManager, AutoSetup< ValidateTapDevices >::Type > > cuttlefish::bootStateMachineComponent

(

)

BreakDeviceName()

Result< DeviceName > cuttlefish::BreakDeviceName

(

const std::string &

device_name

)

BridgeExists()

Result< bool > cuttlefish::BridgeExists

(

std::string_view

name

)

BridgeInUse()

Result< bool > cuttlefish::BridgeInUse

(

std::string_view

name

)

BringUpIface()

Result< void > cuttlefish::BringUpIface

(

std::string_view

name

)

BufferZipSource() [1/2]

Result< SeekableZipSource > cuttlefish::BufferZipSource	(	SeekableZipSource	source,
		size_t	buffer_size
	)

BufferZipSource() [2/2]

Result< SeekableZipSource > cuttlefish::BufferZipSource	(	std::unique_ptr< ReaderSeeker >	data_provider,
		size_t	buffer_size
	)

BuildAPImage()

static bool cuttlefish::BuildAPImage ( const CuttlefishConfig &  config, const CuttlefishConfig::InstanceSpecific &  instance  )

static

BuildCuttlefishLogEvent()

logs::proto::wireless::android::cuttlefish::CuttlefishLogEvent cuttlefish::BuildCuttlefishLogEvent

(

const MetricsData &

metrics_data

)

BuildCvdLoadFlags()

std::vector< Flag > cuttlefish::BuildCvdLoadFlags

(

LoadFlags &

load_flags

)

BuildDlkmImage()

Result< void > cuttlefish::BuildDlkmImage	(	const std::string &	src_dir,
		const bool	is_erofs,
		const std::string &	partition_name,
		const std::string &	output_image
	)

BuildFetcherConfigMember()

Result< CvdFile > cuttlefish::BuildFetcherConfigMember	(	FileSource	purpose,
		std::string	build_id,
		std::string	build_target,
		std::string	path,
		std::string	directory_prefix,
		std::string	archive_source,
		std::string	archive_path
	)

BuildLogRequest()

wireless_android_play_playlog::LogRequest cuttlefish::BuildLogRequest

(

const std::string &

serialized_cf_log_event

)

BuildOSImage()

static bool cuttlefish::BuildOSImage ( const CuttlefishConfig::InstanceSpecific &  instance )

static

BuildVbmetaImage()

Result< void > cuttlefish::BuildVbmetaImage	(	const std::string &	vendor_dlkm_img,
		const std::string &	vbmeta_path
	)

CacheZipSource()

Result< SeekableZipSource > cuttlefish::CacheZipSource	(	SeekableZipSource	inner,
		std::string	file_path
	)

CanAccess()

bool cuttlefish::CanAccess	(	const std::string &	path,
		const int	mode
	)

CanGenerateGrubEsp()

bool cuttlefish::CanGenerateGrubEsp

(

Arch

arch

)

CanHardLink()

Result< bool > cuttlefish::CanHardLink	(	const std::string &	source,
		const std::string &	destination
	)

CanRename()

Result< bool > cuttlefish::CanRename ( const std::string &  source, const std::string &  destination  )

inline

CanRunAutoLogin()

bool cuttlefish::CanRunAutoLogin

(

)

Casimir()

Result< std::vector< MonitorCommand > > cuttlefish::Casimir	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::EnvironmentSpecific &	environment,
		const CuttlefishConfig::InstanceSpecific &	instance,
		LogTeeCreator &	log_tee
	)

CasimirBinary()

std::string cuttlefish::CasimirBinary

(

)

CasimirControlServer()

Result< std::optional< MonitorCommand > > cuttlefish::CasimirControlServer	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::EnvironmentSpecific &	environment,
		const CuttlefishConfig::InstanceSpecific &	instance,
		GrpcSocketCreator &	grpc_socket
	)

CasimirControlServerBinary()

std::string cuttlefish::CasimirControlServerBinary

(

)

ChangeGroup()

Result< void > cuttlefish::ChangeGroup	(	const std::string &	path,
		const std::string &	group_name
	)

ChangeSignalHandlers()

void cuttlefish::ChangeSignalHandlers	(	void(*)(int)	handler,
		std::vector< int >	signals
	)

CharToLogSeverity()

Result< LogSeverity > cuttlefish::CharToLogSeverity

(

char

severity

)

CheckExecNameFromStatus()

static Result< void > cuttlefish::CheckExecNameFromStatus ( const std::string &  exec_name, const pid_t  pid  )

static

CheckProcessExitedNormally()

Result< void > cuttlefish::CheckProcessExitedNormally	(	siginfo_t	infop,
		int	expected_exit_code
	)

ChromeOsCompositeDiskConfig()

std::vector< ImagePartition > cuttlefish::ChromeOsCompositeDiskConfig	(	const CuttlefishConfig::InstanceSpecific &	instance,
		const ChromeOsStateImage &	chrome_os_state
	)

CleanPriorFiles()

Result< void > cuttlefish::CleanPriorFiles	(	const std::set< std::string > &	preserving,
		const std::vector< std::string > &	clean_dirs
	)

CleanupBridgeGateway()

void cuttlefish::CleanupBridgeGateway	(	std::string_view	name,
		std::string_view	ipaddr,
		const GatewayConfig &	config
	)

CleanupEthernetIface()

void cuttlefish::CleanupEthernetIface

(

std::string_view

name

)

CollectFlagsFromHelpxml()

std::optional< std::vector< FlagInfo > > cuttlefish::CollectFlagsFromHelpxml

(

const std::string &

xml_str

)

CollectPids()

Result< std::vector< pid_t > > cuttlefish::CollectPids

(

const uid_t

uid

)

CollectPidsByArgv0()

Result< std::vector< pid_t > > cuttlefish::CollectPidsByArgv0	(	const std::string &	expected_argv0,
		uid_t	uid = getuid()
	)

When argv[0] != exec_path, collects PIDs based on argv[0]

CollectPidsByExecName()

Result< std::vector< pid_t > > cuttlefish::CollectPidsByExecName	(	const std::string &	exec_name,
		const uid_t	uid
	)

CollectPidsByExecPath()

Result< std::vector< pid_t > > cuttlefish::CollectPidsByExecPath	(	const std::string &	exec_path,
		const uid_t	uid
	)

CollectRunCvdGroups()

Result< std::vector< GroupProcInfo > > cuttlefish::CollectRunCvdGroups

(

)

CollectRunCvdProcesses()

Result< std::vector< pid_t > > cuttlefish::CollectRunCvdProcesses

(

)

ColorKernelLine()

Result< std::string > cuttlefish::ColorKernelLine

(

std::string_view

line

)

ColorLauncherLine()

Result< std::string > cuttlefish::ColorLauncherLine

(

std::string_view

line

)

ColorLogcatLine()

Result< std::string > cuttlefish::ColorLogcatLine

(

std::string_view

line

)

ColorLogTeeLine()

Result< std::string > cuttlefish::ColorLogTeeLine

(

std::string_view

line

)

CombinedAndroidBuild()

Result< std::unique_ptr< AndroidBuild > > cuttlefish::CombinedAndroidBuild	(	std::string	name,
		std::vector< std::unique_ptr< AndroidBuild > >
	)

Combines information from multiple AndroidBuild instances.

Individual sources can implement parts of the API, and an instance of this class combines non-error results to provide as much information as possible to the caller.

Instances provided to this class are expected to be part of the same build and consistent with each other. Specifically, if files are from different build targets, have different build ids, or are built from different sources, they should not be combined with each other.

ConfigFlagComponent()

fruit::Component< fruit::Required< SystemImageDirFlag >, ConfigFlag > cuttlefish::ConfigFlagComponent

(

)

ConfigFlagPlaceholder()

fruit::Component< ConfigFlag > cuttlefish::ConfigFlagPlaceholder

(

)

ConfigureGpuSettings()

Result< GpuMode > cuttlefish::ConfigureGpuSettings	(	const gfxstream::proto::GraphicsAvailability &	graphics_availability,
		GpuMode	gpu_mode_arg,
		const std::string &	gpu_vhost_user_mode_arg,
		const std::string &	gpu_renderer_features_arg,
		std::string &	gpu_context_types_arg,
		const std::string &	guest_hwui_renderer_arg,
		const std::string &	guest_renderer_preload_arg,
		VmmMode	vmm,
		const GuestConfig &	guest_config,
		CuttlefishConfig::MutableInstanceSpecific &	instance
	)

ConfigureNetworkSettings()

Result< void > cuttlefish::ConfigureNetworkSettings	(	const std::string &	ril_dns_arg,
		const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	const_instance,
		CuttlefishConfig::MutableInstanceSpecific &	instance
	)

ConsoleForwarder()

Result< std::optional< MonitorCommand > > cuttlefish::ConsoleForwarder

(

const CuttlefishConfig::InstanceSpecific &

instance

)

ConsoleForwarderBinary()

std::string cuttlefish::ConsoleForwarderBinary

(

)

ConsoleForwarderMain()

int cuttlefish::ConsoleForwarderMain	(	int	argc,
		char **	argv
	)

ConsoleInfo()

std::string cuttlefish::ConsoleInfo

(

const CuttlefishConfig::InstanceSpecific &

instance

)

ConsoleInPipeName()

std::string cuttlefish::ConsoleInPipeName

(

const CuttlefishConfig::InstanceSpecific &

ins

)

ConsoleOutPipeName()

std::string cuttlefish::ConsoleOutPipeName

(

const CuttlefishConfig::InstanceSpecific &

ins

)

ConsolePath()

std::string cuttlefish::ConsolePath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

ConsolePipePrefix()

std::string cuttlefish::ConsolePipePrefix

(

const CuttlefishConfig::InstanceSpecific &

ins

)

ConsoleSeverity()

LogSeverity cuttlefish::ConsoleSeverity

(

)

ConstructBuildDesc()

std::string cuttlefish::ConstructBuildDesc ( const std::string &  build_id, const std::string &  build_target  )

inline

ConstructCommand()

Result< Command > cuttlefish::ConstructCommand

(

const ConstructCommandParam &

param

)

ConstructCvdGenericNonHelpCommand()

Result< Command > cuttlefish::ConstructCvdGenericNonHelpCommand	(	const ConstructNonHelpForm &	request_form,
		const CommandRequest &	request
	)

ConstructCvdHelpCommand()

Result< Command > cuttlefish::ConstructCvdHelpCommand	(	const std::string &	bin_file,
		std::unordered_map< std::string, std::string >	envs,
		const std::vector< std::string > &	subcmd_args,
		const CommandRequest &	request
	)

ConstructSiblingHelpCommand()

Result< Command > cuttlefish::ConstructSiblingHelpCommand	(	const std::string &	bin_name,
		const std::unordered_map< std::string, std::string > &	env,
		const std::vector< std::string > &	subcmd_args
	)

ConstructTargetFilepath()

std::string cuttlefish::ConstructTargetFilepath	(	const std::string &	directory,
		const std::string &	filename
	)

ConsumeFlags() [1/2]

Result< void > cuttlefish::ConsumeFlags	(	const std::vector< Flag > &	flags,
		std::vector< std::string > &&	args,
		ConsumeFlagsOpts	opts
	)

ConsumeFlags() [2/2]

Result< void > cuttlefish::ConsumeFlags	(	const std::vector< Flag > &	flags,
		std::vector< std::string > &	args,
		ConsumeFlagsOpts	opts
	)

Contains() [1/3]

template<typename T >

constexpr bool cuttlefish::Contains ( const std::string &  s, T &&  t  )

constexpr

Contains() [2/3]

template<typename T >

constexpr bool cuttlefish::Contains ( const std::string_view &  s, T &&  t  )

constexpr

Contains() [3/3]

template<typename Container , typename U , typename = std::enable_if_t< contains_internal_impl::HasFindImpl<Container, U>::value && (!contains_internal_impl::IsString<Container>::value && !contains_internal_impl::IsStringView<Container>::value), void>>

constexpr bool cuttlefish::Contains ( Container &&  container, U &&  u  )

constexpr

ControlEnvProxyServerBinary()

std::string cuttlefish::ControlEnvProxyServerBinary

(

)

ControlEnvProxyServerComponent()

fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific, GrpcSocketCreator > > cuttlefish::ControlEnvProxyServerComponent

(

)

ControlLoop()

Result< void > cuttlefish::ControlLoop	(	SharedFD	control_socket,
		DisplayHandler &	display_handler,
		RecordingManager &	recording_manager,
		ScreenshotHandler &	screenshot_handler
	)

ConvertChannelLayout()

AudioChannelsLayout cuttlefish::ConvertChannelLayout

(

::cuttlefish::config::Audio_ChannelLayout

layout

)

ConvertSampleRate()

uint32_t cuttlefish::ConvertSampleRate

(

::cuttlefish::config::Audio_SampleRate

rate

)

ConvertToSnapshotCmd()

Result< SnapshotCmd > cuttlefish::ConvertToSnapshotCmd

(

const std::string &

input

)

Copy() [1/2]

Result< void > cuttlefish::Copy	(	Reader &	reader,
		Writer &	writer,
		const size_t	buffer_size
	)

Copy() [2/2]

Result< void > cuttlefish::Copy	(	std::string_view	from,
		std::string_view	to
	)

CopyDirectoryRecursively()

Result< void > cuttlefish::CopyDirectoryRecursively	(	const std::string &	src_dir_path,
		const std::string &	dest_dir_path,
		const bool	verify_dest_dir_empty,
		std::function< bool(const std::string &)>	predicate
	)

On taking snapshot, we should delete dest_dir first. On Restoring, we don't delete the runtime directory, eventually. We could, however, start with deleting it.

CopyToMsdos()

static bool cuttlefish::CopyToMsdos ( const std::string &  image, const std::string &  path, const std::string &  destination  )

static

CopyWithAttributes()

Result< void > cuttlefish::CopyWithAttributes	(	const std::string &	from,
		const std::string &	to
	)

CpioBinary()

std::string cuttlefish::CpioBinary

(

)

Cpus()

static uint32_t cuttlefish::Cpus ( const Instance &  instance )

static

CreateAudioServer()

std::unique_ptr< AudioServer > cuttlefish::CreateAudioServer

(

)

CreateBlankEmptyImage()

Result< void > cuttlefish::CreateBlankEmptyImage	(	std::string_view	image,
		int	num_mb
	)

CreateBlankExt4Image()

Result< void > cuttlefish::CreateBlankExt4Image	(	std::string_view	image,
		int	num_mb
	)

CreateBlankSdcardImage()

Result< void > cuttlefish::CreateBlankSdcardImage	(	std::string_view	image,
		int	num_mb
	)

CreateBridge()

Result< void > cuttlefish::CreateBridge

(

std::string_view

name

)

CreateConfirmationUIComponent()

fruit::Component< ScreenConnector< DisplayHandler::WebRtcScProcessedFrame >, confui::HostServer, confui::HostVirtualInput > cuttlefish::CreateConfirmationUIComponent	(	int *	frames_fd,
		bool *	frames_are_rgba,
		confui::PipeConnectionPair *	pipe_io_pair,
		InputConnector *	input_connector
	)

CreateDynamicDiskFiles()

Result< void > cuttlefish::CreateDynamicDiskFiles	(	const FetcherConfigs &	fetcher_configs,
		const CuttlefishConfig &	config,
		AndroidBuilds &	android_builds,
		const BootImageFlag &	boot_image,
		const SystemImageDirFlag &	system_image_dirs
	)

CreateEthernetBridgeIface()

bool cuttlefish::CreateEthernetBridgeIface	(	std::string_view	name,
		std::string_view	ipaddr
	)

CreateEthernetIface()

bool cuttlefish::CreateEthernetIface	(	std::string_view	name,
		std::string_view	bridge_name
	)

CreateKey()

static bool cuttlefish::CreateKey ( TpmResourceManager &  resource_manager, ESYS_TR  parent_key, TPM2B_PUBLIC *  key_public_out, TPM2B_PRIVATE *  key_private_out, TpmObjectSlot *  key_slot_out  )

static

CreateLogger()

ScopedLogger cuttlefish::CreateLogger

(

std::string_view

metrics_directory

)

CreateMemFDWithData()

SharedFD cuttlefish::CreateMemFDWithData

(

const std::string &

data

)

CreateMetaInfo()

Result< Json::Value > cuttlefish::CreateMetaInfo	(	const CuttlefishConfig &	cuttlefish_config,
		const std::string &	snapshot_path
	)

CreateMobileIface()

bool cuttlefish::CreateMobileIface	(	std::string_view	name,
		uint16_t	id,
		std::string_view	ipaddr
	)

CreateOrReuseAndDrainFifo()

Result< SharedFD > cuttlefish::CreateOrReuseAndDrainFifo	(	const std::string &	path,
		mode_t	mode
	)

CreateOrUpdateCompositeDisk()

Result< void > cuttlefish::CreateOrUpdateCompositeDisk	(	std::vector< ImagePartition >	partitions,
		const std::string &	header_file,
		const std::string &	footer_file,
		const std::string &	output_composite_path,
		bool	read_only
	)

Generate the files necessary for booting with a Composite Disk.

Composite Disk is a crosvm disk format that is a layer of indirection over other disk files. The Composite Disk file lists names and offsets in the virtual disk.

For a complete single disk inside the VM, there must also be a GUID Partition Table header and footer. These are saved to header_file and footer_file, then the specification file containing the file paths and offsets is saved to output_composite_path.

CreateTap()

bool cuttlefish::CreateTap

(

std::string_view

name

)

CreateTempFileWithText()

std::string cuttlefish::CreateTempFileWithText	(	const std::string &	filepath,
		const std::string &	text
	)

CredentialForScopes()

Result< std::unique_ptr< CredentialSource > > cuttlefish::CredentialForScopes	(	HttpClient &	http_client,
		const std::vector< std::string > &	scopes
	)

CrosvmCpuArguments()

Result< std::vector< std::string > > cuttlefish::CrosvmCpuArguments

(

const Json::Value &

vcpu_config_json

)

CurlHttpClient()

std::unique_ptr< HttpClient > cuttlefish::CurlHttpClient

(

bool

use_logging_debug_function

)

CurrentDirectory()

std::string cuttlefish::CurrentDirectory

(

)

CurrentUserName()

Result< std::string > cuttlefish::CurrentUserName

(

)

CustomActionsComponent()

fruit::Component< fruit::Required< ConfigFlag >, CustomActionConfigProvider > cuttlefish::CustomActionsComponent

(

)

CustomConfigsFlags()

static Result< std::vector< std::string > > cuttlefish::CustomConfigsFlags ( const EnvironmentSpecification &  cfg )

static

CustomConfigsFlagValue()

static Result< std::optional< std::string > > cuttlefish::CustomConfigsFlagValue ( const Instance &  instance )

static

CuttlefishMain()

int cuttlefish::CuttlefishMain

(

)

CvdallocBinary()

std::string cuttlefish::CvdallocBinary

(

)

CvdallocComponent()

fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific > > cuttlefish::CvdallocComponent

(

)

CvdallocInterfaceName()

std::string cuttlefish::CvdallocInterfaceName	(	const std::string &	name,
		int	num
	)

CvdallocMain()

Result< int > cuttlefish::CvdallocMain	(	int	argc,
		char *	argv[]
	)

CvdCacheHome()

Result< std::string > cuttlefish::CvdCacheHome

(

)

CvdConfigDirs()

Result< std::vector< std::string > > cuttlefish::CvdConfigDirs

(

)

CvdConfigHome()

Result< std::string > cuttlefish::CvdConfigHome

(

)

CvdDataDirs()

Result< std::vector< std::string > > cuttlefish::CvdDataDirs

(

)

CvdDataHome()

Result< std::string > cuttlefish::CvdDataHome

(

)

CvdDir()

std::string cuttlefish::CvdDir

(

)

CvdRuntimeDir()

std::string cuttlefish::CvdRuntimeDir

(

)

CvdStateHome()

Result< std::string > cuttlefish::CvdStateHome

(

)

CvdUserLogDir()

std::string cuttlefish::CvdUserLogDir

(

)

A user-specific directory where log files from cvd are stored.

DataImagePolicyFromString()

DataImagePolicy cuttlefish::DataImagePolicyFromString

(

std::string_view

policy

)

DataImagePolicyString()

std::string cuttlefish::DataImagePolicyString

(

DataImagePolicy

policy

)

DeAndroidSparse2()

Result< void > cuttlefish::DeAndroidSparse2

(

const std::vector< std::string > &

image_files

)

Converts any Android-Sparse image files in image_files to raw image files.

Android-Sparse is a file format invented by Android that optimizes for chunks of zeroes or repeated data. The Android build system can produce sparse files to save on size of disk files after they are extracted from a disk file, as the imag eflashing process also can handle Android-Sparse images.

crosvm has read-only support for Android-Sparse files, but QEMU does not support them.

DECLARE_TYPE() [1/6]

cuttlefish::DECLARE_TYPE	(	Be16	,
		uint16_t	,
		htobe16	,
		be16toh
	)

DECLARE_TYPE() [2/6]

cuttlefish::DECLARE_TYPE	(	Be32	,
		uint32_t	,
		htobe32	,
		be32toh
	)

DECLARE_TYPE() [3/6]

cuttlefish::DECLARE_TYPE	(	Be64	,
		uint64_t	,
		htobe64	,
		be64toh
	)

DECLARE_TYPE() [4/6]

cuttlefish::DECLARE_TYPE	(	Le16	,
		uint16_t	,
		htole16	,
		le16toh
	)

DECLARE_TYPE() [5/6]

cuttlefish::DECLARE_TYPE	(	Le32	,
		uint32_t	,
		htole32	,
		le32toh
	)

DECLARE_TYPE() [6/6]

cuttlefish::DECLARE_TYPE	(	Le64	,
		uint64_t	,
		htole64	,
		le64toh
	)

DecodeBase64()

Result< std::vector< uint8_t > > cuttlefish::DecodeBase64

(

std::string_view

data

)

DefaultDisplays()

InstanceDisplays cuttlefish::DefaultDisplays

(

)

DefaultEnvironmentPath()

std::string cuttlefish::DefaultEnvironmentPath	(	const std::string &	environment_key,
		const std::string &	default_value,
		const std::string &	subpath
	)

DefaultGamepadSpec()

std::string cuttlefish::DefaultGamepadSpec

(

)

DefaultGuestImagePath()

std::string cuttlefish::DefaultGuestImagePath

(

const std::string &

file_name

)

DefaultHostArtifactsPath()

std::string cuttlefish::DefaultHostArtifactsPath

(

const std::string &

file_name

)

DefaultKeyboardSpec()

std::string cuttlefish::DefaultKeyboardSpec

(

)

DefaultMouseSpec()

std::string cuttlefish::DefaultMouseSpec

(

)

DefaultMultiTouchpadSpecTemplate()

std::string cuttlefish::DefaultMultiTouchpadSpecTemplate

(

)

DefaultMultiTouchscreenSpecTemplate()

std::string cuttlefish::DefaultMultiTouchscreenSpecTemplate

(

)

DefaultNetworkInterfaces()

Result< IfaceConfig > cuttlefish::DefaultNetworkInterfaces

(

const CuttlefishConfig::InstanceSpecific &

instance

)

DefaultQemuBinaryDir()

std::string cuttlefish::DefaultQemuBinaryDir

(

)

DefaultRecord()

gatekeeper::failure_record_t cuttlefish::DefaultRecord

(

gatekeeper::secure_id_t

secure_user_id

)

DefaultRotaryDeviceSpec()

std::string cuttlefish::DefaultRotaryDeviceSpec

(

)

DefaultSingleTouchpadSpecTemplate()

std::string cuttlefish::DefaultSingleTouchpadSpecTemplate

(

)

DefaultSingleTouchscreenSpecTemplate()

std::string cuttlefish::DefaultSingleTouchscreenSpecTemplate

(

)

DefaultsMain()

Result< int > cuttlefish::DefaultsMain	(	int	argc,
		char *	argv[]
	)

DefaultSubprocessLogging()

void cuttlefish::DefaultSubprocessLogging	(	char *	argv[],
		MetadataLevel	stderr_level
	)

DefaultSwitchesSpec()

std::string cuttlefish::DefaultSwitchesSpec

(

)

DeleteIface()

Result< void > cuttlefish::DeleteIface

(

std::string_view

name

)

DeserializeDisjointRangeSet()

Result< DisjointRangeSet > cuttlefish::DeserializeDisjointRangeSet

(

std::string_view

data

)

DeserializeTimePoint()

Result< TimeStamp > cuttlefish::DeserializeTimePoint

(

const Json::Value &

time_point_json

)

DestroyBridge()

bool cuttlefish::DestroyBridge

(

std::string_view

name

)

DestroyEthernetBridgeIface()

bool cuttlefish::DestroyEthernetBridgeIface	(	std::string_view	name,
		std::string_view	ipaddr
	)

DestroyEthernetIface()

bool cuttlefish::DestroyEthernetIface

(

std::string_view

name

)

DestroyGateway()

Result< void > cuttlefish::DestroyGateway	(	std::string_view	name,
		std::string_view	gateway,
		std::string_view	netmask
	)

DestroyIface()

bool cuttlefish::DestroyIface

(

std::string_view

name

)

DestroyMobileIface()

bool cuttlefish::DestroyMobileIface	(	std::string_view	name,
		uint16_t	id,
		std::string_view	ipaddr
	)

DetectGceEnvironment()

Result< std::optional< GceEnvironment > > cuttlefish::DetectGceEnvironment

(

)

DetectGitHubRepository()

std::optional< GitHubRepository > cuttlefish::DetectGitHubRepository

(

)

DeviceEventTypeString()

std::string cuttlefish::DeviceEventTypeString

(

DeviceEventType

event_type

)

DeviceId()

std::string cuttlefish::DeviceId

(

const Instance &

instance

)

DeviceTypeToStringView()

std::string_view cuttlefish::DeviceTypeToStringView

(

DeviceType

device_type

)

DirectoryContents()

Result< std::vector< std::string > > cuttlefish::DirectoryContents

(

const std::string &

path

)

DirectoryContentsPaths()

Result< std::vector< std::string > > cuttlefish::DirectoryContentsPaths

(

const std::string &

path

)

DirectoryCrc()

static std::map< std::string, uint32_t > cuttlefish::DirectoryCrc ( const std::string &  path )

static

DirectoryExists()

bool cuttlefish::DirectoryExists	(	const std::string &	path,
		bool	follow_symlinks
	)

DiskImageFlagsVectorization()

Result< void > cuttlefish::DiskImageFlagsVectorization	(	CuttlefishConfig &	config,
		const FetcherConfigs &	fetcher_configs,
		const AndroidEfiLoaderFlag &	android_efi_loader,
		const BootImageFlag &	boot_image,
		const BootloaderFlag &	bootloader,
		const InitramfsPathFlag &	initramfs_path,
		const KernelPathFlag &	kernel_path,
		const SuperImageFlag &	super_image,
		const SystemImageDirFlag &	system_image_dir,
		const VendorBootImageFlag &	vendor_boot_image
	)

DisplayPrivacyNotice()

void cuttlefish::DisplayPrivacyNotice

(

)

DisplaysConfigsComponent()

fruit::Component< DisplaysConfigs > cuttlefish::DisplaysConfigsComponent

(

)

DisplaysConfigsFlagComponent()

fruit::Component< fruit::Required< DisplaysConfigs, ConfigFlag >, DisplaysConfigsFlag > cuttlefish::DisplaysConfigsFlagComponent

(

)

DisplaysConfigsFragmentComponent()

fruit::Component< fruit::Required< DisplaysConfigs >, DisplaysConfigsFragment > cuttlefish::DisplaysConfigsFragmentComponent

(

)

DisplaysFlag()

Result< std::optional< InstancesDisplays > > cuttlefish::DisplaysFlag

(

std::vector< std::string >

args

)

DnsmasqPath()

Result< std::string > cuttlefish::DnsmasqPath

(

)

DownloadFileWithBackup()

Result< std::string > cuttlefish::DownloadFileWithBackup	(	BuildApi &	build_api,
		const Build &	build,
		const std::string &	target_directory,
		const std::string &	artifact_name,
		const std::string &	backup_artifact_name
	)

DrainInotifyEvents()

Result< uint32_t > cuttlefish::DrainInotifyEvents

(

SharedFD

inotify_fd

)

DropPrivileges()

int cuttlefish::DropPrivileges

(

uid_t

orig

)

EchoServer()

MonitorCommand cuttlefish::EchoServer

(

GrpcSocketCreator &

grpc_socket

)

EchoServerBinary()

std::string cuttlefish::EchoServerBinary

(

)

EmptyCache()

Result< void > cuttlefish::EmptyCache

(

const std::string &

cache_directory

)

EnableBootAnimation()

static bool cuttlefish::EnableBootAnimation ( const Instance &  instance )

static

EnableNetsimNfc()

bool cuttlefish::EnableNetsimNfc

(

const CuttlefishConfig &

config

)

EnablePkvm()

static bool cuttlefish::EnablePkvm ( const Instance &  instance )

static

EnableSandbox()

static bool cuttlefish::EnableSandbox ( const Instance &  instance )

static

EncodeBase64() [1/2]

Result< std::string > cuttlefish::EncodeBase64	(	const void *	data,
		size_t	size
	)

EncodeBase64() [2/2]

Result< std::string > cuttlefish::EncodeBase64

(

std::string_view

data

)

EnforceHostConfigured()

static Result< void > cuttlefish::EnforceHostConfigured ( )

static

EnforceVbMetaSize()

Result< void > cuttlefish::EnforceVbMetaSize

(

const std::string &

path

)

EnsureDirectoryExists()

Result< void > cuttlefish::EnsureDirectoryExists	(	const std::string &	directory_path,
		const mode_t	mode,
		const std::string &	group_name
	)

EnvironmentToString()

std::string cuttlefish::EnvironmentToString

(

ClearcutEnvironment

environment

)

EnvpToMap()

std::unordered_map< std::string, std::string > cuttlefish::EnvpToMap

(

char **

envp

)

ErrorFromType() [1/3]

auto cuttlefish::ErrorFromType ( bool  )

inline

ErrorFromType() [2/3]

template<typename T >

auto cuttlefish::ErrorFromType

(

Result< T > &

value

)

ErrorFromType() [3/3]

template<typename T >

auto cuttlefish::ErrorFromType ( std::optional< T >  )

inline

EspRequiredForAPBootFlow()

static bool cuttlefish::EspRequiredForAPBootFlow ( APBootFlow  ap_boot_flow )

static

EspRequiredForBootFlow()

static bool cuttlefish::EspRequiredForBootFlow ( BootFlow  flow )

static

EstablishAndMaintainConnection()

void cuttlefish::EstablishAndMaintainConnection

(

const std::string &

address

)

Execute() [1/2]

int cuttlefish::Execute

(

std::vector< std::string >

command

)

Returns the exit status on success, negative values on error

If failed in fork() or exec(), returns -1. If the child exited from an unhandled signal, returns -1. Otherwise, returns the exit status.

TODO: Changes return type to Result<int>

For now, too many callsites expects int, and needs quite a lot of changes if we change the return type.

Execute() [2/2]

Result< siginfo_t > cuttlefish::Execute	(	std::vector< std::string >	command,
		SubprocessOptions	subprocess_options,
		int	wait_options
	)

Similar as the one above but returns CF_ERR instead of -1, and siginfo_t instead of the exit status.

ExpandProductPaths()

std::vector< std::string > cuttlefish::ExpandProductPaths	(	const std::string &	product_path,
		size_t	num_instances
	)

ExtractArchiveContents()

Result< std::vector< std::string > > cuttlefish::ExtractArchiveContents	(	const std::string &	archive_filepath,
		const std::string &	target_directory,
		const bool	keep_archive
	)

ExtractArchiveToMemory()

std::string cuttlefish::ExtractArchiveToMemory	(	const std::string &	archive_filepath,
		const std::string &	archive_member
	)

ExtractCvdArgs()

Result< selector::SelectorOptions > cuttlefish::ExtractCvdArgs

(

std::vector< std::string > &

args

)

ExtractFile()

Result< void > cuttlefish::ExtractFile	(	ReadableZip &	zip,
		std::string_view	zip_path,
		const std::string &	host_path
	)

ExtractImage()

Result< std::string > cuttlefish::ExtractImage	(	const std::string &	archive_filepath,
		const std::string &	target_directory,
		const std::string &	image,
		const bool	keep_archive
	)

ExtractImageContents()

Result< std::vector< std::string > > cuttlefish::ExtractImageContents	(	const std::string &	image_filepath,
		const std::string &	target_dir,
		const bool	keep_archive
	)

ExtractImages()

Result< std::vector< std::string > > cuttlefish::ExtractImages	(	const std::string &	archive_filepath,
		const std::string &	target_directory,
		const std::vector< std::string > &	images,
		const bool	keep_archive
	)

ExtractLaunchTemplates() [1/2]

Result< cvd::config::EnvironmentSpecification > cuttlefish::ExtractLaunchTemplates

(

cvd::config::EnvironmentSpecification

config

)

ExtractLaunchTemplates() [2/2]

Result< EnvironmentSpecification > cuttlefish::ExtractLaunchTemplates

(

EnvironmentSpecification

config

)

ExtractProcInfo()

Result< ProcInfo > cuttlefish::ExtractProcInfo

(

const pid_t

pid

)

FakePRead()

Result< uint64_t > cuttlefish::FakePRead	(	ReaderSeeker &	,
		void *	buf,
		uint64_t	count,
		uint64_t	offset
	)

Best-effort fake pread(2) using Read() and Seek*() calls.

Will not call PRead() on the ReaderSeeker instance.

FakePWrite()

Result< uint64_t > cuttlefish::FakePWrite	(	WriterSeeker &	,
		const void *	buf,
		uint64_t	count,
		uint64_t	offset
	)

Best-effort fake pwrite(2) using Write() and Seek*() calls.

Will not call PWrite() on the WriterSeeker instance.

FastbootConfigComponent()

fruit::Component< FastbootConfig > cuttlefish::FastbootConfigComponent

(

)

FastbootConfigFlagComponent()

fruit::Component< fruit::Required< FastbootConfig, ConfigFlag >, FastbootConfigFlag > cuttlefish::FastbootConfigFlagComponent

(

)

FastbootConfigFragmentComponent()

fruit::Component< fruit::Required< FastbootConfig >, FastbootConfigFragment > cuttlefish::FastbootConfigFragmentComponent

(

)

FetchCvdMain()

Result< FetchResult > cuttlefish::FetchCvdMain

(

const FetchFlags &

flags

)

FetchedAndroidBuild()

Result< std::unique_ptr< AndroidBuild > > cuttlefish::FetchedAndroidBuild	(	const FetcherConfig &	,
		FileSource
	)

Represents a build downloaded by cvd fetch.

FetchHostPackage()

Result< void > cuttlefish::FetchHostPackage	(	BuildApi &	build_api,
		const Build &	build,
		const std::string &	target_dir,
		const bool	keep_archives,
		const std::vector< std::string > &	host_substitutions,
		FetchTracer::Trace	trace
	)

FetchInstanceStatus()

Result< Json::Value > cuttlefish::FetchInstanceStatus	(	LocalInstance &	instance,
		std::chrono::seconds	timeout
	)

FetchLabel()

std::string cuttlefish::FetchLabel

(

const Build &

build

)

FileCrc()

uint32_t cuttlefish::FileCrc

(

const std::string &

path

)

FileDeviceId()

Result< dev_t > cuttlefish::FileDeviceId

(

const std::string &

path

)

FileEquals()

bool cuttlefish::FileEquals	(	const std::string &	file1,
		const std::string &	file2
	)

FileExists()

bool cuttlefish::FileExists	(	const std::string &	path,
		bool	follow_symlinks
	)

FileHasContent()

bool cuttlefish::FileHasContent

(

const std::string &

path

)

FileIsSocket()

bool cuttlefish::FileIsSocket

(

const std::string &

path

)

FileModificationTime()

Result< std::chrono::system_clock::time_point > cuttlefish::FileModificationTime

(

const std::string &

path

)

FileOwner()

Result< uid_t > cuttlefish::FileOwner

(

const std::string &

path

)

FileOwnerUid()

static Result< uid_t > cuttlefish::FileOwnerUid ( const std::string &  file_path )

static

FileSize()

off_t cuttlefish::FileSize

(

const std::string &

path

)

FilterLauncherLine()

Result< bool > cuttlefish::FilterLauncherLine	(	LogSeverity	filter,
		std::string_view	line
	)

FilterLogcatLine()

Result< bool > cuttlefish::FilterLogcatLine	(	LogSeverity	filter,
		std::string_view	line
	)

FilterLogTeeLine()

Result< bool > cuttlefish::FilterLogTeeLine	(	LogSeverity	filter,
		std::string_view	line
	)

FilterSeverity()

bool cuttlefish::FilterSeverity	(	LogSeverity	filter_severity,
		LogSeverity	test_severity
	)

FinalizeTcti()

static void cuttlefish::FinalizeTcti ( TSS2_TCTI_CONTEXT *  tcti_context )

static

FindBuildArchive() [1/2]

Result< BuildArchive > cuttlefish::FindBuildArchive	(	const FetcherConfig &	,
		FileSource	,
		std::string_view	pattern
	)

Scan a FetcherConfig for an archive containing the substring pattern. This could be a zip file still present, or the extracted contents of a zip file that was downloaded.

FindBuildArchive() [2/2]

Result< BuildArchive > cuttlefish::FindBuildArchive	(	const std::string &	directory_path,
		std::string_view	pattern
	)

Scan the contents of directory_path to find a file whose name contains pattern as a substring, and is a zip archive.

FindConfig()

bool cuttlefish::FindConfig	(	const std::vector< std::string > &	vec,
		const std::string &	element
	)

FindConfigIgnoreSpaces()

bool cuttlefish::FindConfigIgnoreSpaces	(	const std::vector< std::string > &	vec,
		const std::string &	str
	)

FindCvdDataFiles()

Result< std::vector< std::string > > cuttlefish::FindCvdDataFiles

(

std::string_view

path

)

FindFile()

Result< std::string > cuttlefish::FindFile	(	const std::string &	path,
		const std::string &	target_name
	)

FixGroupsIfNecessary()

static Command cuttlefish::FixGroupsIfNecessary ( const std::string &  command_name, const std::string &  bin_path  )

static

flagXml()

std::optional< std::map< std::string, std::string > > cuttlefish::flagXml

(

const Flag &

f

)

ForcefullyStopGroup()

Result< void > cuttlefish::ForcefullyStopGroup

(

const uid_t

any_id_in_group

)

ForceRawImage()

Result< void > cuttlefish::ForceRawImage

(

const std::string &

image_path

)

ForCurrentInstance()

std::string cuttlefish::ForCurrentInstance

(

const char *

prefix

)

Format()

std::string cuttlefish::Format

(

const TimeStamp &

time_point

)

format_as() [1/13]

std::string_view cuttlefish::format_as

(

Arch

arch

)

format_as() [2/13]

std::string cuttlefish::format_as

(

const AndroidBuild &

build

)

format_as() [3/13]

std::string cuttlefish::format_as

(

const AndroidBuildKey &

key

)

format_as() [4/13]

std::string cuttlefish::format_as

(

const AndroidBuilds &

builds

)

format_as() [5/13]

std::string cuttlefish::format_as

(

const BuildArchive &

archive

)

format_as() [6/13]

std::string cuttlefish::format_as

(

const PrettyContainerType &

pc

)

format_as() [7/13]

std::string cuttlefish::format_as

(

const PrettyStruct &

ps

)

format_as() [8/13]

std::string_view cuttlefish::format_as

(

DeviceType

device_type

)

format_as() [9/13]

std::string_view cuttlefish::format_as

(

ExternalNetworkMode

net

)

format_as() [10/13]

std::string_view cuttlefish::format_as

(

FileSource

source

)

format_as() [11/13]

std::string_view cuttlefish::format_as

(

GpuMode

mode

)

format_as() [12/13]

std::string_view cuttlefish::format_as

(

SafeLevel

level

)

format_as() [13/13]

std::string_view cuttlefish::format_as

(

VmmMode

vmm

)

FormatByteSize()

std::string cuttlefish::FormatByteSize

(

uint64_t

size

)

FormatFlagsHelp()

std::string cuttlefish::FormatFlagsHelp	(	const std::vector< Flag > &	flags,
		size_t	max_line_width
	)

FormatHelpText()

std::string cuttlefish::FormatHelpText	(	const std::vector< HelpParagraph > &	text,
		size_t	max_line_width
	)

FormatKernelLine()

std::string cuttlefish::FormatKernelLine

(

const KernelLine &

line

)

FormatLauncherLine()

std::string cuttlefish::FormatLauncherLine

(

const LauncherLine &

line

)

FormatLogcatLine()

std::string cuttlefish::FormatLogcatLine

(

const LogcatLine &

line

)

FormatLogTeeLine()

std::string cuttlefish::FormatLogTeeLine

(

const LogTeeLine &

line

)

FromSeverity()

std::string cuttlefish::FromSeverity

(

LogSeverity

severity

)

FuchsiaCompositeDiskConfig()

std::vector< ImagePartition > cuttlefish::FuchsiaCompositeDiskConfig

(

const CuttlefishConfig::InstanceSpecific &

instance

)

GamepadCaptureServerPath()

std::string cuttlefish::GamepadCaptureServerPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

GamepadEventsServerPath()

std::string cuttlefish::GamepadEventsServerPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

GamepadSocketPath()

std::string cuttlefish::GamepadSocketPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

GatherFetchCompleteMetrics()

void cuttlefish::GatherFetchCompleteMetrics	(	const std::string &	target_directory,
		const FetchResult &	fetch_result
	)

GatherFetchFailedMetrics()

void cuttlefish::GatherFetchFailedMetrics

(

const std::string &

target_directory

)

GatherFetchStartMetrics()

void cuttlefish::GatherFetchStartMetrics

(

const FetchFlags &

fetch_flags

)

GatherMetrics()

Result< MetricsData > cuttlefish::GatherMetrics

(

const MetricsInput &

metrics_input

)

GatherVmBootCompleteMetrics()

void cuttlefish::GatherVmBootCompleteMetrics

(

const LocalInstanceGroup &

instance_group

)

GatherVmBootFailedMetrics()

void cuttlefish::GatherVmBootFailedMetrics

(

const LocalInstanceGroup &

instance_group

)

GatherVmInstantiationMetrics()

void cuttlefish::GatherVmInstantiationMetrics

(

const LocalInstanceGroup &

instance_group

)

GatherVmStartMetrics()

void cuttlefish::GatherVmStartMetrics

(

const LocalInstanceGroup &

instance_group

)

GatherVmStopMetrics()

void cuttlefish::GatherVmStopMetrics

(

const LocalInstanceGroup &

instance_group

)

Gem5ImageUnpacker()

Result< void > cuttlefish::Gem5ImageUnpacker	(	const CuttlefishConfig &	config,
		const BootImageFlag &	boot_image
	)

GenerateBootFlags() [1/2]

Result< std::vector< std::string > > cuttlefish::GenerateBootFlags

(

const cvd::config::EnvironmentSpecification &

)

GenerateBootFlags() [2/2]

Result< std::vector< std::string > > cuttlefish::GenerateBootFlags

(

const EnvironmentSpecification &

cfg

)

GenerateConnectivityFlags() [1/2]

std::vector< std::string > cuttlefish::GenerateConnectivityFlags

(

const cvd::config::EnvironmentSpecification &

)

GenerateConnectivityFlags() [2/2]

std::vector< std::string > cuttlefish::GenerateConnectivityFlags

(

const EnvironmentSpecification &

cfg

)

GenerateCorrespondingIpv6ForMac()

void cuttlefish::GenerateCorrespondingIpv6ForMac	(	const uint8_t	mac[6],
		uint8_t	out[16]
	)

Linux uses mac to generate link-local IPv6 address following:

1. Get mac address (for example 00:1a:11:ee:cf:01)
2. Throw ff:fe as a 3th and 4th octets (00:1a:11 :ff:fe: ee:cf:01)
3. Flip 2th bit in the first octet (02: 1a:11:ff:fe:ee:cf:01)
4. Use IPv6 format (021a:11ff:feee:cf01)
5. Add prefix fe80:: (fe80::021a:11ff:feee:cf01 or fe80:0000:0000:0000:021a:11ff:feee:cf00)

GenerateDiskFlags() [1/2]

std::vector< std::string > cuttlefish::GenerateDiskFlags

(

const cvd::config::EnvironmentSpecification &

)

GenerateDiskFlags() [2/2]

std::vector< std::string > cuttlefish::GenerateDiskFlags

(

const EnvironmentSpecification &

config

)

GenerateEthMacForInstance()

void cuttlefish::GenerateEthMacForInstance	(	int	index,
		uint8_t	out[6]
	)

GenerateFlag()

template<typename T >

std::string cuttlefish::GenerateFlag	(	const std::string &	name,
		const T &	value
	)

GenerateGraphicsFlags() [1/2]

Result< std::vector< std::string > > cuttlefish::GenerateGraphicsFlags

(

const cvd::config::EnvironmentSpecification &

)

GenerateGraphicsFlags() [2/2]

Result< std::vector< std::string > > cuttlefish::GenerateGraphicsFlags

(

const EnvironmentSpecification &

cfg

)

GenerateInstanceFlag()

template<typename T >

std::string cuttlefish::GenerateInstanceFlag	(	const std::string &	name,
		const cvd::config::EnvironmentSpecification &	config,
		T	callback
	)

GenerateInstancesFlags() [1/2]

Result< std::vector< std::string > > cuttlefish::GenerateInstancesFlags

(

const cvd::config::EnvironmentSpecification &

cfg

)

GenerateInstancesFlags() [2/2]

Result< std::vector< std::string > > cuttlefish::GenerateInstancesFlags

(

const EnvironmentSpecification &

cfg

)

GenerateMediaFlags() [1/2]

Result< std::vector< std::string > > cuttlefish::GenerateMediaFlags

(

const cvd::config::EnvironmentSpecification &

cfg

)

GenerateMediaFlags() [2/2]

Result< std::vector< std::string > > cuttlefish::GenerateMediaFlags

(

const EnvironmentSpecification &

cfg

)

GenerateMobileMacForInstance()

void cuttlefish::GenerateMobileMacForInstance	(	int	index,
		uint8_t	out[6]
	)

GenerateRandomString()

std::string cuttlefish::GenerateRandomString	(	const std::string &	alphabet,
		const int	length
	)

GenerateSecurityFlags() [1/2]

std::vector< std::string > cuttlefish::GenerateSecurityFlags

(

const cvd::config::EnvironmentSpecification &

cfg

)

GenerateSecurityFlags() [2/2]

std::vector< std::string > cuttlefish::GenerateSecurityFlags

(

const EnvironmentSpecification &

cfg

)

GenerateSessionIdFile()

Result< void > cuttlefish::GenerateSessionIdFile

(

const std::string &

metrics_directory

)

GenerateStreamingFlags() [1/2]

std::vector< std::string > cuttlefish::GenerateStreamingFlags

(

const cvd::config::EnvironmentSpecification &

)

GenerateStreamingFlags() [2/2]

std::vector< std::string > cuttlefish::GenerateStreamingFlags

(

const EnvironmentSpecification &

cfg

)

GenerateUuid()

std::string cuttlefish::GenerateUuid

(

)

GenerateVecFlag()

template<typename T >

std::string cuttlefish::GenerateVecFlag	(	const std::string &	name,
		const T &	collection
	)

GenerateVmFlags() [1/2]

Result< std::vector< std::string > > cuttlefish::GenerateVmFlags

(

const cvd::config::EnvironmentSpecification &

)

GenerateVmFlags() [2/2]

Result< std::vector< std::string > > cuttlefish::GenerateVmFlags

(

const EnvironmentSpecification &

cfg

)

GenerateWifiMacForInstance()

void cuttlefish::GenerateWifiMacForInstance	(	int	index,
		uint8_t	out[6]
	)

GetAcloudOauthFilepath()

std::string cuttlefish::GetAcloudOauthFilepath

(

)

GetArrayValues()

template<typename T >

Result< std::vector< T > > cuttlefish::GetArrayValues	(	const Json::Value &	array,
		const std::vector< std::string > &	selectors
	)

GetATCommand() [1/2]

std::string cuttlefish::GetATCommand	(	const std::string &	plmn,
		int32_t	identifierType,
		int32_t	protocolMessage,
		bool	isEmergency
	)

Allows for the serialization of aidl::android::hardware::radio::network::CellularIdentifierDisclosure objects into an AT command that can be processed by the cuttlefish RIL to trigger unsolicited calls to aidl::android::hardware::radio::network::IRadioNetworkIndication::cellularIdentifierDisclosed.

GetATCommand() [2/2]

std::string cuttlefish::GetATCommand	(	int32_t	connection_event,
		int32_t	encryption,
		int32_t	integrity,
		bool	is_unprotected_emergency
	)

Constructs the AT command that updates the security algorithm that is reported by the cuttlefish RIL. The handler of the AT command will trigger unsolicited calls to aidl::android::hardware::radio::network::IRadioNetworkIndication::securityAlgorithmsUpdated.

GetBuildIdAndTarget()

std::tuple< std::string, std::string > cuttlefish::GetBuildIdAndTarget

(

const Build &

build

)

GetCacheSize()

Result< size_t > cuttlefish::GetCacheSize

(

const std::string &

cache_directory

)

GetCatchallApiKey()

std::string cuttlefish::GetCatchallApiKey

(

)

GetChannelsCount()

static constexpr uint8_t cuttlefish::GetChannelsCount ( AudioChannelsLayout  layout )

inlinestaticconstexpr

GetCmdArgs()

Result< std::vector< std::string > > cuttlefish::GetCmdArgs

(

const pid_t

pid

)

GetColorForSeverity()

std::string_view cuttlefish::GetColorForSeverity

(

LogSeverity

severity

)

GetCombinedDynamicPartitions()

Result< MiscInfo > cuttlefish::GetCombinedDynamicPartitions	(	const MiscInfo &	vendor_info,
		const MiscInfo &	system_info,
		const std::set< std::string > &	extracted_images
	)

GetConfigFilePath()

std::string cuttlefish::GetConfigFilePath

(

const CuttlefishConfig &

config

)

GetCreatedFileListFromInotifyFd()

std::vector< std::string > cuttlefish::GetCreatedFileListFromInotifyFd

(

int

fd

)

GetCredentialSourceFromFlags()

Result< std::unique_ptr< CredentialSource > > cuttlefish::GetCredentialSourceFromFlags	(	HttpClient &	http_client,
		const BuildApiFlags &	flags,
		const std::string &	oauth_filepath,
		const std::string &	scope
	)

GetCuttlefishConfigPath()

Result< std::string > cuttlefish::GetCuttlefishConfigPath

(

const std::string &

home

)

GetCvdCredentialFilepaths()

Result< std::vector< std::string > > cuttlefish::GetCvdCredentialFilepaths

(

)

GetCvdLogFileName()

std::string cuttlefish::GetCvdLogFileName	(	const std::string &	log_dir = CvdUserLogDir(),
		std::chrono::system_clock::time_point	now = std::chrono::system_clock::now()
	)

Returns the path to a new timestamped log file for the cvd command. The log file is created in PerUserDir() + "/logs/" with a name like cvd_YYYYMMDD_HHMMSS.ms.log. If the logs directory cannot be created, the function returns std::nullopt.

GetDefaultVsockCid()

int cuttlefish::GetDefaultVsockCid

(

)

GetDiskUsageBytes()

Result< size_t > cuttlefish::GetDiskUsageBytes

(

const std::string &

path

)

GetDiskUsageGigabytes()

Result< size_t > cuttlefish::GetDiskUsageGigabytes

(

const std::string &

path

)

GetEnvironmentSpecification()

Result< cvd::config::EnvironmentSpecification > cuttlefish::GetEnvironmentSpecification	(	const std::string &	config_path,
		const std::map< std::string, std::string, std::less< void > > &	overrides
	)

GetEnvs()

Result< std::unordered_map< std::string, std::string > > cuttlefish::GetEnvs

(

const pid_t

pid

)

GetExecutablePath()

Result< std::string > cuttlefish::GetExecutablePath

(

const pid_t

pid

)

GetFailureRecordImpl()

static Result< void > cuttlefish::GetFailureRecordImpl ( secure_env::Storage &  storage, uint32_t  uid, gatekeeper::secure_id_t  secure_user_id, gatekeeper::failure_record_t *  record  )

static

GetFetchLogsFileName()

std::string cuttlefish::GetFetchLogsFileName

(

const std::string &

target_directory

)

GetFetchMetrics()

Result< FetchMetrics > cuttlefish::GetFetchMetrics

(

const FetchInput &

fetch_input

)

GetFileListFromInotifyFd()

std::vector< std::string > cuttlefish::GetFileListFromInotifyFd	(	int	fd,
		uint32_t	mask
	)

GetFilepath() [1/2]

std::optional< std::string > cuttlefish::GetFilepath

(

const Build &

build

)

GetFilepath() [2/2]

std::optional< std::string > cuttlefish::GetFilepath

(

const BuildString &

build_string

)

GetFlagDefaultsFromConfig()

Result< Defaults > cuttlefish::GetFlagDefaultsFromConfig

(

)

GetFlagMetrics()

Result< FlagMetrics > cuttlefish::GetFlagMetrics	(	const ParsedFlags &	parsed_flags,
		const int	guest_index
	)

GetGlobalConfigFileLink()

std::string cuttlefish::GetGlobalConfigFileLink

(

)

GetGraphicsAvailabilityWithSubprocessCheck()

gfxstream::proto::GraphicsAvailability cuttlefish::GetGraphicsAvailabilityWithSubprocessCheck

(

)

GetGroupCreationDirectories() [1/2]

Result< InstanceManager::GroupDirectories > cuttlefish::GetGroupCreationDirectories	(	const std::string &	parent_directory,
		const cvd::config::EnvironmentSpecification &	env_spec
	)

GetGroupCreationDirectories() [2/2]

Result< InstanceManager::GroupDirectories > cuttlefish::GetGroupCreationDirectories	(	const std::string &	parent_directory,
		const EnvironmentSpecification &	env_spec
	)

GetGuestMetrics()

Result< std::vector< GuestMetrics > > cuttlefish::GetGuestMetrics

(

const Guests &

guests

)

GetHostInfo()

HostInfo cuttlefish::GetHostInfo

(

)

GetHostMetrics()

Result< HostMetrics > cuttlefish::GetHostMetrics

(

)

GetInstance()

int cuttlefish::GetInstance

(

)

GetInvoker()

Invoker cuttlefish::GetInvoker

(

)

GetLauncherMonitor()

Result< SharedFD > cuttlefish::GetLauncherMonitor	(	const CuttlefishConfig &	config,
		const int	instance_num,
		int	timeout_seconds
	)

GetLauncherMonitorFromInstance()

Result< SharedFD > cuttlefish::GetLauncherMonitorFromInstance	(	const CuttlefishConfig::InstanceSpecific &	instance_config,
		const int	timeout_seconds
	)

GetOptional() [1/2]

template<typename T >

std::optional< T > cuttlefish::GetOptional	(	const std::vector< std::optional< T > > &	vector,
		size_t	i
	)

GetOptional() [2/2]

template<typename T >

std::optional< T > cuttlefish::GetOptional	(	const std::vector< T > &	vector,
		size_t	i
	)

GetParsedFlags()

Result< ParsedFlags > cuttlefish::GetParsedFlags

(

)

GetPartitionGUID()

Result< const uint8_t * > cuttlefish::GetPartitionGUID

(

GptPartitionType

type

)

GetSeccompPolicyDir()

std::string cuttlefish::GetSeccompPolicyDir

(

)

GetSerializedEventProto()

Result< std::string > cuttlefish::GetSerializedEventProto

(

const std::string &

event_filepath

)

GetSiblingCommandFlags()

Result< std::vector< Flag > > cuttlefish::GetSiblingCommandFlags	(	const std::string &	bin_name,
		const std::unordered_map< std::string, std::string > &	env,
		std::vector< std::string >	args
	)

GetTerminalSize()

Result< TerminalSize > cuttlefish::GetTerminalSize

(

)

GetUserName()

std::optional< std::string > cuttlefish::GetUserName

(

uid_t

uid

)

GetValue()

template<typename T >

Result< T > cuttlefish::GetValue	(	const Json::Value &	root,
		const std::vector< std::string > &	selectors
	)

GetVbmetaArgs()

Result< VbmetaArgs > cuttlefish::GetVbmetaArgs	(	const MiscInfo &	misc_info,
		const std::string &	image_path
	)

GetVersionIds()

VersionIdentifiers cuttlefish::GetVersionIds

(

)

GetVsockServerPort()

int cuttlefish::GetVsockServerPort	(	const int	base,
		const int	vsock_guest_cid
	)

Parameters

vsock_guest_cid

per instance guest cid

GflagsBaseInstanceFlag()

static Result< std::optional< int32_t > > cuttlefish::GflagsBaseInstanceFlag ( )

static

GflagsCompatFlag() [1/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		bool &	value
	)

GflagsCompatFlag() [2/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		int32_t &	value
	)

GflagsCompatFlag() [3/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		size_t &	value
	)

GflagsCompatFlag() [4/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::optional< bool > &	value,
		CoerceToNullopt	opt
	)

GflagsCompatFlag() [5/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::optional< BuildString > &	value
	)

GflagsCompatFlag() [6/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::optional< int > &	value,
		CoerceToNullopt	opt
	)

GflagsCompatFlag() [7/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::optional< int64_t > &	value,
		CoerceToNullopt	opt
	)

GflagsCompatFlag() [8/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::optional< size_t > &	value,
		CoerceToNullopt	opt
	)

GflagsCompatFlag() [9/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::optional< std::string > &	value,
		CoerceToNullopt	opt
	)

GflagsCompatFlag() [10/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::optional< std::vector< std::string > > &	value,
		CoerceToNullopt	opt
	)

GflagsCompatFlag() [11/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::optional< std::vector< unsigned > > &	value,
		CoerceToNullopt	opt
	)

GflagsCompatFlag() [12/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::optional< unsigned > &	value,
		CoerceToNullopt	opt
	)

GflagsCompatFlag() [13/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::string &	value
	)

GflagsCompatFlag() [14/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::vector< bool > &	value,
		const bool	default_value
	)

GflagsCompatFlag() [15/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::vector< std::optional< BuildString > > &	value
	)

GflagsCompatFlag() [16/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::vector< std::optional< ChromeOsBuildString > > &	value
	)

GflagsCompatFlag() [17/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::vector< std::string > &	value
	)

GflagsCompatFlag() [18/18]

Flag cuttlefish::GflagsCompatFlag	(	const std::string &	name,
		std::vector< unsigned > &	value
	)

GflagsComponent()

fruit::Component< fruit::Required< ConfigFlag >, ParseGflags > cuttlefish::GflagsComponent

(

)

GflagsInstanceNumsFlag()

static Result< std::vector< int32_t > > cuttlefish::GflagsInstanceNumsFlag ( )

static

GflagsNumInstancesFlag()

static Result< std::optional< int32_t > > cuttlefish::GflagsNumInstancesFlag ( )

static

GnssGrpcProxyBinary()

std::string cuttlefish::GnssGrpcProxyBinary

(

)

GnssGrpcProxyServer()

Result< std::optional< MonitorCommand > > cuttlefish::GnssGrpcProxyServer	(	const CuttlefishConfig::InstanceSpecific &	instance,
		GrpcSocketCreator &	grpc_socket
	)

GpuModeFromString()

Result< GpuMode > cuttlefish::GpuModeFromString

(

std::string_view

mode

)

GpuModeString()

std::string cuttlefish::GpuModeString

(

GpuMode

mode

)

GroupDirFromHome()

Result< std::string > cuttlefish::GroupDirFromHome

(

std::string_view

dir

)

GroupIdFromName()

gid_t cuttlefish::GroupIdFromName

(

const std::string &

group_name

)

GrubMakeImage()

template<typename T >

static bool cuttlefish::GrubMakeImage ( const std::string &  prefix, const std::string &  format, const std::string &  directory, const std::string &  output, const T &  modules  )

static

GuessSeverity()

static LogSeverity cuttlefish::GuessSeverity ( const std::string &  env_var, LogSeverity  default_value  )

static

GuestOsFromBootFlow()

GuestOs cuttlefish::GuestOsFromBootFlow

(

BootFlow

boot_flow

)

GuestSnapshotDirectories()

Result< std::vector< std::string > > cuttlefish::GuestSnapshotDirectories

(

const std::string &

snapshot_path

)

HandleCallback()

int64_t cuttlefish::HandleCallback	(	ReadableZipSourceCallback &	callbacks,
		zip_error_t *	error,
		void *	data,
		uint64_t	len,
		zip_source_cmd_t	cmd
	)

HandleCmds()

Result< std::string > cuttlefish::HandleCmds	(	const std::string &	grpc_socket_path,
		const std::string &	cmd,
		const std::vector< std::string > &	args
	)

HandleHostGroupSnapshot()

Result< std::string > cuttlefish::HandleHostGroupSnapshot

(

const std::string &

path

)

cp -r <cuttlefish home dir> <snapshot_path> write meta info for cvd: i.e. HOME, group name, instance names returns the path of generated snapshot json file

Takes the snapshot of instance group

This may includes the snapshot for cvd_env, etc. However, for now, we also take per-instance host snapshot here.

TODO(kwstephenkim): separate host instance specific snapshot from the host group snapshot

HasHelpFlag()

Result< bool > cuttlefish::HasHelpFlag

(

const std::vector< std::string > &

args

)

HasValue()

bool cuttlefish::HasValue ( const Json::Value &  root, const std::vector< std::string > &  selectors  )

inline

HeaderValue()

std::optional< std::string_view > cuttlefish::HeaderValue	(	const std::vector< HttpHeader > &	headers,
		std::string_view	header_name
	)

HelpFlag()

Flag cuttlefish::HelpFlag	(	const std::vector< Flag > &	flags,
		std::string	text
	)

HelpXmlFlag()

Flag cuttlefish::HelpXmlFlag	(	const std::vector< Flag > &	flags,
		std::ostream &	out,
		bool &	print_xml,
		std::string	text
	)

HexToBytes()

Result< std::vector< uint8_t > > cuttlefish::HexToBytes

(

const std::string &

hex_string

)

HostArch()

Arch cuttlefish::HostArch

(

)

HostArchStr()

const std::string & cuttlefish::HostArchStr

(

)

Returns e.g. aarch64, x86_64, etc

HostBinaryDir()

std::string cuttlefish::HostBinaryDir

(

)

HostBinaryPath()

std::string cuttlefish::HostBinaryPath

(

const std::string &

binary_name

)

HostPackageSubstitution()

Result< void > cuttlefish::HostPackageSubstitution	(	const std::string &	target_dir,
		const std::vector< std::string > &	host_substitutions
	)

HostQemuBiosPath()

std::string cuttlefish::HostQemuBiosPath

(

)

HostSupportsQemuCli()

bool cuttlefish::HostSupportsQemuCli

(

)

HostToolsCrc()

std::map< std::string, uint32_t > cuttlefish::HostToolsCrc

(

)

HostUsrSharePath()

std::string cuttlefish::HostUsrSharePath

(

const std::string &

file

)

HttpGetToFile()

Result< HttpResponse< std::string > > cuttlefish::HttpGetToFile	(	HttpClient &	http_client,
		const std::string &	url,
		const std::string &	path,
		const std::vector< std::string > &	headers
	)

HttpGetToJson()

Result< HttpResponse< Json::Value > > cuttlefish::HttpGetToJson	(	HttpClient &	http_client,
		const std::string &	url,
		const std::vector< std::string > &	headers
	)

HttpGetToString()

Result< HttpResponse< std::string > > cuttlefish::HttpGetToString	(	HttpClient &	http_client,
		const std::string &	url,
		const std::vector< std::string > &	headers
	)

HttpPostToJson() [1/2]

Result< HttpResponse< Json::Value > > cuttlefish::HttpPostToJson	(	HttpClient &	http_client,
		const std::string &	url,
		const Json::Value &	data,
		const std::vector< std::string > &	headers
	)

HttpPostToJson() [2/2]

Result< HttpResponse< Json::Value > > cuttlefish::HttpPostToJson	(	HttpClient &	http_client,
		const std::string &	url,
		const std::string &	data,
		const std::vector< std::string > &	headers
	)

HttpPostToString()

Result< HttpResponse< std::string > > cuttlefish::HttpPostToString	(	HttpClient &	http_client,
		const std::string &	url,
		const std::string &	data,
		const std::vector< std::string > &	headers
	)

HumanFriendlyStateName()

std::string cuttlefish::HumanFriendlyStateName

(

cvd::InstanceState

state

)

HwcomposerPmemPath()

std::string cuttlefish::HwcomposerPmemPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

IdentifyAndroidBuild() [1/2]

Result< std::unique_ptr< AndroidBuild > > cuttlefish::IdentifyAndroidBuild

(

const AndroidBuildKey &

android_build_key

)

IdentifyAndroidBuild() [2/2]

Result< std::unique_ptr< AndroidBuild > > cuttlefish::IdentifyAndroidBuild	(	const std::string &	system_image_dir,
		const FetcherConfig &	config,
		FileSource	source
	)

ImageFromFile()

Result< std::unique_ptr< DiskImage > > cuttlefish::ImageFromFile

(

const std::string &

file_path

)

ImageStatusToStringView()

std::string_view cuttlefish::ImageStatusToStringView

(

FakeAndroidBuild::ImageStatus

image_status

)

ImgZip() [1/2]

Result< std::unique_ptr< AndroidBuild > > cuttlefish::ImgZip	(	const FetcherConfig &	config,
		FileSource	source
	)

Represents the <build target>-img-<build id>.zip file produced by the Android build system, possibly in an extracted form produced by cvd fetch.

Expected to contain super.img and other .img files that are physical partitions. Does not contain .img files for the logical partitions inside super.

Also expected to contain the android-info.txt file and/or the cuttlefish-guest-config.txtpb file. See go/cf-guest-config-pb for more information.

ImgZip() [2/2]

Result< std::unique_ptr< AndroidBuild > > cuttlefish::ImgZip

(

const std::string &

path

)

InGroup()

bool cuttlefish::InGroup

(

const std::string &

group

)

InitChromeOsArgs()

static void cuttlefish::InitChromeOsArgs ( LinuxEspBuilder &  linux_esp_builder )

static

InitializeAccessKregistryImage()

Result< void > cuttlefish::InitializeAccessKregistryImage

(

const CuttlefishConfig::InstanceSpecific &

instance

)

InitializeCuttlefishConfiguration()

Result< CuttlefishConfig > cuttlefish::InitializeCuttlefishConfiguration	(	const std::string &	root_dir,
		const std::vector< GuestConfig > &	guest_configs,
		fruit::Injector<> &	injector,
		const FetcherConfigs &	fetcher_configs,
		const BootImageFlag &	boot_image,
		const InitramfsPathFlag &	initramfs_path,
		const KernelPathFlag &	kernel_path,
		const SuperImageFlag &	super_image,
		const SystemImageDirFlag &	system_image_dir,
		const VendorBootImageFlag &	vendor_boot_image,
		const VmManagerFlag &	vm_manager_flag,
		const Defaults &	defaults
	)

InitializeDataImage()

Result< void > cuttlefish::InitializeDataImage

(

const CuttlefishConfig::InstanceSpecific &

instance

)

InitializeEspImage()

Result< void > cuttlefish::InitializeEspImage	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance
	)

InitializeHwcomposerPmemImage()

Result< void > cuttlefish::InitializeHwcomposerPmemImage

(

const CuttlefishConfig::InstanceSpecific &

instance

)

InitializePflash()

Result< void > cuttlefish::InitializePflash

(

const CuttlefishConfig::InstanceSpecific &

instance

)

InitializePstore()

Result< void > cuttlefish::InitializePstore

(

const CuttlefishConfig::InstanceSpecific &

instance

)

InitializeSdCard()

Result< void > cuttlefish::InitializeSdCard	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance
	)

InitLinuxArgs()

static void cuttlefish::InitLinuxArgs ( Arch  target_arch, LinuxEspBuilder &  linux_esp_builder  )

static

InMemoryFilesystem()

std::unique_ptr< ReadWriteFilesystem > cuttlefish::InMemoryFilesystem

(

)

InMemoryIo() [1/3]

std::unique_ptr< ReaderWriterSeeker > cuttlefish::InMemoryIo

(

)

InMemoryIo() [2/3]

std::unique_ptr< ReaderWriterSeeker > cuttlefish::InMemoryIo

(

std::string_view

str

)

InMemoryIo() [3/3]

std::unique_ptr< ReaderWriterSeeker > cuttlefish::InMemoryIo

(

std::vector< char >

data

)

InSandbox()

bool cuttlefish::InSandbox

(

)

InstanceDatabasePath()

std::string cuttlefish::InstanceDatabasePath

(

)

InstanceFromEnvironment()

int cuttlefish::InstanceFromEnvironment

(

)

InstanceFromString()

int cuttlefish::InstanceFromString

(

std::string

instance_str

)

InstanceGuestSnapshotPath()

Result< std::string > cuttlefish::InstanceGuestSnapshotPath	(	const Json::Value &	meta_json,
		const std::string &	instance_id
	)

InstanceImageFiles()

std::vector< std::vector< std::unique_ptr< ImageFile > > > cuttlefish::InstanceImageFiles	(	const CuttlefishConfig &	config,
		const BootImageFlag &	boot_image_flag
	)

InstanceLocksPath()

std::string cuttlefish::InstanceLocksPath

(

)

InstanceNums()

static Result< std::vector< int > > cuttlefish::InstanceNums ( )

static

InstanceToBridgedWifiAddress()

std::string cuttlefish::InstanceToBridgedWifiAddress

(

int

num

)

InstanceToBridgedWifiBroadcast()

std::string cuttlefish::InstanceToBridgedWifiBroadcast

(

int

num

)

InstanceToBridgedWifiGatewayAddress()

std::string cuttlefish::InstanceToBridgedWifiGatewayAddress

(

int

num

)

InstanceToMobileAddress()

std::string cuttlefish::InstanceToMobileAddress

(

int

num

)

InstanceToMobileBroadcast()

std::string cuttlefish::InstanceToMobileBroadcast

(

int

num

)

InstanceToMobileGatewayAddress()

std::string cuttlefish::InstanceToMobileGatewayAddress

(

int

num

)

InstanceToWifiAddress()

std::string cuttlefish::InstanceToWifiAddress

(

int

num

)

InstanceToWifiBroadcast()

std::string cuttlefish::InstanceToWifiBroadcast

(

int

num

)

InstanceToWifiGatewayAddress()

std::string cuttlefish::InstanceToWifiGatewayAddress

(

int

num

)

INSTANTIATE_TEST_SUITE_P() [1/8]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	SelectGroup	,
		FrontlineParserTestFixture	,
		::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "--group_name=group", "subcmd", "arg1", "arg2"},.expected_args={"cvd", "subcmd", "arg1", "arg2"},.expected_options=selector::SelectorOptions{ .group_name="group",.instance_names=std::nullopt}})
	)

INSTANTIATE_TEST_SUITE_P() [2/8]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	SelectGroupAndInstances	,
		FrontlineParserTestFixture	,
		::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "--instance_name=a,b,c", "-group_name=group", "subcmd", "arg1", "arg2"},.expected_args={"cvd", "subcmd", "arg1", "arg2"},.expected_options=selector::SelectorOptions{ .group_name="group",.instance_names=std::vector< std::string >{ "a", "b", "c", }}})
	)

INSTANTIATE_TEST_SUITE_P() [3/8]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	SelectNoArgs	,
		FrontlineParserTestFixture	,
		::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "subcmd"},.expected_args={"cvd", "subcmd"},.expected_options=selector::SelectorOptions{ .group_name=std::nullopt,.instance_names=std::nullopt}})
	)

INSTANTIATE_TEST_SUITE_P() [4/8]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	SelectNoSelectors	,
		FrontlineParserTestFixture	,
		::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "subcmd", "arg1", "arg2"},.expected_args={"cvd", "subcmd", "arg1", "arg2"},.expected_options=selector::SelectorOptions{ .group_name=std::nullopt,.instance_names=std::nullopt}})
	)

INSTANTIATE_TEST_SUITE_P() [5/8]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	SelectNoSubCmd	,
		FrontlineParserTestFixture	,
		::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "--group_name=group", "--instance_name=1"},.expected_args={"cvd"},.expected_options=selector::SelectorOptions{ .group_name="group",.instance_names=std::vector< std::string >{"1"}}})
	)

INSTANTIATE_TEST_SUITE_P() [6/8]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	SelectNoSubCmdNoSelectors	,
		FrontlineParserTestFixture	,
		::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd"},.expected_args={"cvd"},.expected_options=selector::SelectorOptions{ .group_name=std::nullopt,.instance_names=std::nullopt}})
	)

INSTANTIATE_TEST_SUITE_P() [7/8]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	SelectOneInstance	,
		FrontlineParserTestFixture	,
		::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "--instance_name=1", "subcmd", "arg1", "arg2"},.expected_args={"cvd", "subcmd", "arg1", "arg2"},.expected_options=selector::SelectorOptions{ .group_name=std::nullopt,.instance_names=std::vector< std::string >{"1"}}})
	)

INSTANTIATE_TEST_SUITE_P() [8/8]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	SelectWithEmptyInstanceNames	,
		FrontlineParserTestFixture	,
		::testing::Values(ExtractCvdArgsTestParams{ .input_args={"cvd", "--instance_name=a,,", "-group_name=group", "subcmd", "arg1", "arg2"},.expected_args={"cvd", "subcmd", "arg1", "arg2"},.expected_options=selector::SelectorOptions{ .group_name="group",.instance_names=std::vector< std::string >{ "a", "", "", }}})
	)

InterfaceName()

static Result< std::string > cuttlefish::InterfaceName ( const CuttlefishConfig::InstanceSpecific &  instance, const std::string &  name  )

static

IntFromGlobalGflags()

Result< FromGflags< int > > cuttlefish::IntFromGlobalGflags	(	const gflags::CommandLineFlagInfo &	flag_info,
		const std::string &	flag_name
	)

IptableConfig()

Result< void > cuttlefish::IptableConfig	(	std::string_view	iptables_path,
		std::string_view	network,
		bool	add
	)

IptablesPath()

Result< std::string > cuttlefish::IptablesPath

(

)

Ipv6ToString()

std::string cuttlefish::Ipv6ToString

(

const uint8_t

ip[16]

)

IsCsiFinalByte()

bool cuttlefish::IsCsiFinalByte

(

char

c

)

IsDirectoryEmpty()

Result< bool > cuttlefish::IsDirectoryEmpty

(

const std::string &

path

)

IsGfxstreamGuestAngleMode()

bool cuttlefish::IsGfxstreamGuestAngleMode

(

GpuMode

mode

)

IsGfxstreamMode()

bool cuttlefish::IsGfxstreamMode

(

GpuMode

mode

)

IsGoogleCorp()

bool cuttlefish::IsGoogleCorp

(

)

IsGuestRenderingMode()

bool cuttlefish::IsGuestRenderingMode

(

GpuMode

mode

)

IsHostCompatible()

bool cuttlefish::IsHostCompatible

(

Arch

arch

)

IsKernelModuleSigned()

Result< bool > cuttlefish::IsKernelModuleSigned

(

ReaderSeeker &

file

)

IsKvmAccessible()

bool cuttlefish::IsKvmAccessible

(

)

IsNvencCodecSupported()

bool cuttlefish::IsNvencCodecSupported	(	GUID	codec_guid,
		int	device_id
	)

IsPopulated()

bool cuttlefish::IsPopulated

(

const Oauth2ConsentRequest &

request

)

IsRestoring()

bool cuttlefish::IsRestoring

(

const CuttlefishConfig &

config

)

IsRunningInContainer()

bool cuttlefish::IsRunningInContainer

(

)

IsSparseImage()

Result< bool > cuttlefish::IsSparseImage

(

const std::string &

image_path

)

IsSymlink()

Result< bool > cuttlefish::IsSymlink

(

const std::string &

path

)

IsValidAndroidHostOutPath()

bool cuttlefish::IsValidAndroidHostOutPath

(

const std::string &

path

)

IsValidDeviceName()

bool cuttlefish::IsValidDeviceName

(

const std::string &

token

)

IsValidGroupName()

bool cuttlefish::IsValidGroupName

(

const std::string &

token

)

IsValidInstanceName()

bool cuttlefish::IsValidInstanceName

(

const std::string &

token

)

JsIndexToLinux()

uint16_t cuttlefish::JsIndexToLinux

(

const int32_t &

index_code

)

KernelCommandLineFromConfig()

std::vector< std::string > cuttlefish::KernelCommandLineFromConfig	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance
	)

KernelCommandLineImpl() [1/2]

static std::string cuttlefish::KernelCommandLineImpl ( const boot_img_hdr_v0 &  v0 )

static

KernelCommandLineImpl() [2/2]

static std::string cuttlefish::KernelCommandLineImpl ( const boot_img_hdr_v3 &  v3 )

static

KernelLogMonitorBinary()

std::string cuttlefish::KernelLogMonitorBinary

(

)

KernelLogMonitorComponent()

fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific >, KernelLogPipeProvider > cuttlefish::KernelLogMonitorComponent

(

)

KernelLogMonitorSource()

std::unique_ptr< MonitorSource > cuttlefish::KernelLogMonitorSource

(

const LocalInstance &

instance

)

KernelLogPipeName()

std::string cuttlefish::KernelLogPipeName

(

const CuttlefishConfig::InstanceSpecific &

ins

)

KernelSize() [1/2]

static uint32_t cuttlefish::KernelSize ( const boot_img_hdr_v0 &  v0 )

static

KernelSize() [2/2]

static uint32_t cuttlefish::KernelSize ( const boot_img_hdr_v3 &  v3 )

static

KeyboardCaptureServerPath()

std::string cuttlefish::KeyboardCaptureServerPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

KeyboardEventsServerPath()

std::string cuttlefish::KeyboardEventsServerPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

KeyboardSocketPath()

std::string cuttlefish::KeyboardSocketPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

KillAllCuttlefishInstances()

Result< void > cuttlefish::KillAllCuttlefishInstances

(

bool

clear_runtime_dirs

)

KillSubprocess()

StopperResult cuttlefish::KillSubprocess

(

Subprocess *

subprocess

)

KillSubprocessFallback() [1/2]

SubprocessStopper cuttlefish::KillSubprocessFallback

(

std::function< StopperResult()>

nice

)

KillSubprocessFallback() [2/2]

SubprocessStopper cuttlefish::KillSubprocessFallback

(

SubprocessStopper

nice_stopper

)

kSimPinSizeRange()

const std::pair< int, int > cuttlefish::kSimPinSizeRange	(	4	,
		8
	)

LastUpdatedInputDisk()

static std::chrono::system_clock::time_point cuttlefish::LastUpdatedInputDisk ( const std::vector< ImagePartition > &  partitions )

static

LaunchAdbComponent()

fruit::Component< fruit::Required< KernelLogPipeProvider, const AdbConfig, const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific > > cuttlefish::LaunchAdbComponent

(

)

LaunchCvdParserTester()

Result< std::vector< std::string > > cuttlefish::LaunchCvdParserTester

(

const Json::Value &

root

)

LauncherLogMonitorSource()

std::unique_ptr< MonitorSource > cuttlefish::LauncherLogMonitorSource	(	const LocalInstance &	instance,
		const LogSeverity	severity
	)

LauncherMonitorSocketPath()

std::string cuttlefish::LauncherMonitorSocketPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

LaunchFastbootComponent()

fruit::Component< fruit::Required< KernelLogPipeProvider, const CuttlefishConfig::InstanceSpecific, const FastbootConfig > > cuttlefish::LaunchFastbootComponent

(

)

launchStreamerComponent()

fruit::Component< fruit::Required< const CuttlefishConfig, KernelLogPipeProvider, InputPathsProvider, const CuttlefishConfig::InstanceSpecific, const CustomActionConfigProvider, WebRtcController > > cuttlefish::launchStreamerComponent

(

)

Length() [1/2]

Result< uint64_t > cuttlefish::Length

(

ReaderWriterSeeker &

seeker

)

Length() [2/2]

Result< uint64_t > cuttlefish::Length

(

Seeker &

seeker

)

LinkOrCopy()

Result< std::string > cuttlefish::LinkOrCopy	(	const std::string &	target,
		const std::string &	destination,
		const bool	overwrite_existing
	)

LinkOrCopyDirectoryContentsRecursively()

Result< void > cuttlefish::LinkOrCopyDirectoryContentsRecursively	(	const std::string &	source,
		const std::string &	destination
	)

LinkTapToBridge()

Result< void > cuttlefish::LinkTapToBridge	(	std::string_view	tap_name,
		std::string_view	bridge_name
	)

LinuxCompositeDiskConfig()

std::vector< ImagePartition > cuttlefish::LinuxCompositeDiskConfig

(

const CuttlefishConfig::InstanceSpecific &

instance

)

LoadFromFile() [1/2]

Result< Json::Value > cuttlefish::LoadFromFile

(

const std::string &

path_to_file

)

LoadFromFile() [2/2]

Result< Json::Value > cuttlefish::LoadFromFile

(

Reader &

json_reader

)

LoadKey()

static TpmObjectSlot cuttlefish::LoadKey ( TpmResourceManager &  resource_manager, ESYS_TR  parent_key, const TPM2B_PUBLIC *  key_public, const TPM2B_PRIVATE *  key_private  )

static

LoadMetaJson()

Result< Json::Value > cuttlefish::LoadMetaJson

(

const std::string &

snapshot_path

)

LoadTemplateByName()

static Result< Json::Value > cuttlefish::LoadTemplateByName ( const std::string &  template_name )

static

LogcatMonitorSource()

std::unique_ptr< MonitorSource > cuttlefish::LogcatMonitorSource	(	const LocalInstance &	instance,
		const LogSeverity	severity
	)

LogcatPath()

std::string cuttlefish::LogcatPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

LogcatPipeName()

std::string cuttlefish::LogcatPipeName

(

const CuttlefishConfig::InstanceSpecific &

ins

)

LogcatReceiver()

Result< MonitorCommand > cuttlefish::LogcatReceiver

(

const CuttlefishConfig::InstanceSpecific &

instance

)

LogcatReceiverBinary()

std::string cuttlefish::LogcatReceiverBinary

(

)

LogFileSeverity()

LogSeverity cuttlefish::LogFileSeverity

(

)

LogStringToDir()

Result< void > cuttlefish::LogStringToDir	(	const CuttlefishConfig::InstanceSpecific &	instance,
		std::string_view	name,
		std::string_view	contents
	)

LogToFiles()

void cuttlefish::LogToFiles	(	const std::vector< std::string > &	files,
		const std::string &	log_prefix
	)

LogToStderr()

void cuttlefish::LogToStderr	(	const std::string &	log_prefix,
		MetadataLevel	metadata_level,
		std::optional< LogSeverity >	severity
	)

LogToStderrAndFiles()

void cuttlefish::LogToStderrAndFiles	(	const std::vector< std::string > &	files,
		const std::string &	log_prefix,
		MetadataLevel	stderr_level,
		std::optional< LogSeverity >	stderr_severity
	)

Lz4LegacyReader()

Result< std::unique_ptr< Reader > > cuttlefish::Lz4LegacyReader

(

std::unique_ptr< Reader >

source

)

Lz4LegacyWriter()

Result< std::unique_ptr< Writer > > cuttlefish::Lz4LegacyWriter

(

std::unique_ptr< Writer >

sink

)

MacAddressToString()

std::string cuttlefish::MacAddressToString

(

const uint8_t

mac[6]

)

main()

int cuttlefish::main	(	int	argc,
		char **	argv
	)

MakeFatImage()

Result< void > cuttlefish::MakeFatImage	(	const std::string &	data_image,
		int	data_image_mb,
		int	offset_num_mb
	)

MakeFileExecutable()

bool cuttlefish::MakeFileExecutable

(

const std::string &

path

)

makeSafeCallback() [1/3]

template<typename T >

std::function< void()> cuttlefish::makeSafeCallback	(	T *	me,
		std::function< void(T *)>	f
	)

makeSafeCallback() [2/3]

template<typename T , typename... Params>

std::function< void()> cuttlefish::makeSafeCallback	(	T *	obj,
		void(T::*)(const Params &...)	f,
		const Params &...	params
	)

makeSafeCallback() [3/3]

template<typename T , typename... Params>

std::function< void()> cuttlefish::makeSafeCallback	(	T *	obj,
		void(T::*)(Params...)	f,
		const Params &...	params
	)

matchAttestationId()

bool cuttlefish::matchAttestationId	(	keymaster_blob_t	blob,
		const std::vector< uint8_t > &	id
	)

MATCHER() [1/2]

cuttlefish::MATCHER	(	IsError	,
		"an error result"
	)

MATCHER() [2/2]

cuttlefish::MATCHER	(	IsOk	,
		"an ok result"
	)

MATCHER_P() [1/2]

cuttlefish::MATCHER_P	(	IsErrorAndMessage	,
		message_matcher	,
		""
	)

MATCHER_P() [2/2]

cuttlefish::MATCHER_P	(	IsOkAndValue	,
		result_value_matcher	,
		""
	)

McopyBinary()

std::string cuttlefish::McopyBinary

(

)

McuComponent()

fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific, LogTeeCreator > > cuttlefish::McuComponent

(

)

MediaConfigsComponent()

fruit::Component< MediaConfigs > cuttlefish::MediaConfigsComponent

(

)

MediaConfigsFlagComponent()

fruit::Component< fruit::Required< MediaConfigs, ConfigFlag >, MediaConfigsFlag > cuttlefish::MediaConfigsFlagComponent

(

)

MediaConfigsFragmentComponent()

fruit::Component< fruit::Required< MediaConfigs >, MediaConfigsFragment > cuttlefish::MediaConfigsFragmentComponent

(

)

MemoryMb()

static uint32_t cuttlefish::MemoryMb ( const Instance &  instance )

static

MergeMiscInfos()

Result< MiscInfo > cuttlefish::MergeMiscInfos	(	const MiscInfo &	vendor_info,
		const MiscInfo &	system_info,
		const MiscInfo &	combined_dp_info,
		const std::vector< std::string > &	system_partitions
	)

MergeResults()

std::vector< std::string > cuttlefish::MergeResults	(	std::vector< std::string >	first_list,
		std::vector< std::string >	scond_list
	)

MergeTwoJsonObjs()

void cuttlefish::MergeTwoJsonObjs	(	Json::Value &	dst,
		const Json::Value &	src
	)

This function merges two json objects and override json tree in dst with src json keys.

Parameters

dst	: destination json object tree(modified in place)
src	: input json object tree to be merged

MkenvimageSlim()

Result< void > cuttlefish::MkenvimageSlim	(	const std::string &	input_path,
		const std::string &	output_path,
		size_t	env_size
	)

MkenvimageSlimMain()

Result< void > cuttlefish::MkenvimageSlimMain	(	int	argc,
		char **	argv
	)

MkfsFat()

std::string cuttlefish::MkfsFat

(

)

MkuserimgMke2fsBinary()

std::string cuttlefish::MkuserimgMke2fsBinary

(

)

MmdBinary()

std::string cuttlefish::MmdBinary

(

)

MobileGatewayName()

std::string cuttlefish::MobileGatewayName	(	std::string_view	ipaddr,
		uint16_t	id
	)

MobileNetworkName()

std::string cuttlefish::MobileNetworkName	(	std::string_view	ipaddr,
		std::string_view	netmask,
		uint16_t	id
	)

ModemSimulator()

Result< std::optional< MonitorCommand > > cuttlefish::ModemSimulator

(

const CuttlefishConfig::InstanceSpecific &

instance

)

ModemSimulatorBinary()

std::string cuttlefish::ModemSimulatorBinary

(

)

ModemSimulatorSimType()

static int32_t cuttlefish::ModemSimulatorSimType ( const Instance &  instance )

static

MonitorLogs()

Result< void > cuttlefish::MonitorLogs	(	const LocalInstance &	instance,
		SharedFD	stop_eventfd,
		LogSeverity	severity
	)

MouseCaptureServerPath()

std::string cuttlefish::MouseCaptureServerPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

MouseEventsServerPath()

std::string cuttlefish::MouseEventsServerPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

MouseSocketPath()

std::string cuttlefish::MouseSocketPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

MoveDirectoryContents()

Result< void > cuttlefish::MoveDirectoryContents	(	const std::string &	source,
		const std::string &	destination
	)

MoveIfChanged()

bool cuttlefish::MoveIfChanged	(	const std::string &	src,
		const std::string &	dst
	)

MsdosMakeDirectories()

static bool cuttlefish::MsdosMakeDirectories ( const std::string &  image_path, const std::vector< std::string > &  directories  )

static

NetsimdBinary()

std::string cuttlefish::NetsimdBinary

(

)

NetsimServerComponent()

fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific, GrpcSocketCreator > > cuttlefish::NetsimServerComponent

(

)

NetworkInterfaceExists()

bool cuttlefish::NetworkInterfaceExists

(

const std::string &

interface_name

)

NewCvdMonitorCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdMonitorCommandHandler

(

InstanceManager &

instance_manager

)

NewfsMsdos()

std::string cuttlefish::NewfsMsdos

(

)

NewZipError()

ManagedZipError cuttlefish::NewZipError

(

)

next_tombstone_path()

static std::string cuttlefish::next_tombstone_path ( const std::string &  dir )

static

NfcConnector()

Result< std::optional< MonitorCommand > > cuttlefish::NfcConnector	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::EnvironmentSpecific &	environment,
		const CuttlefishConfig::InstanceSpecific &	instance
	)

NoGroupMessage()

std::string cuttlefish::NoGroupMessage

(

const CommandRequest &

request

)

Oauth2Login()

Result< std::unique_ptr< CredentialSource > > cuttlefish::Oauth2Login	(	HttpClient &	http_client,
		const Oauth2ConsentRequest &	request
	)

OneshotHmac()

static UniqueEsysPtr< TPM2B_DIGEST > cuttlefish::OneshotHmac ( TpmResourceManager &  resource_manager, ESYS_TR  key_handle, TpmAuth  auth, const uint8_t *  data, size_t  data_size  )

static

OpenwrtArgsFromConfig()

std::unordered_map< std::string, std::string > cuttlefish::OpenwrtArgsFromConfig

(

const CuttlefishConfig::InstanceSpecific &

instance

)

OpenWrtComponent()

fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::EnvironmentSpecific, const CuttlefishConfig::InstanceSpecific, LogTeeCreator, WmediumdServer, Cvdalloc > > cuttlefish::OpenWrtComponent

(

)

OpenwrtControlServerBinary()

std::string cuttlefish::OpenwrtControlServerBinary

(

)

OpenwrtControlServerComponent()

fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::EnvironmentSpecific, GrpcSocketCreator > > cuttlefish::OpenwrtControlServerComponent

(

)

OpenZip()

Result< ReadableZip > cuttlefish::OpenZip	(	BuildApi &	build_api,
		const Build &	build,
		const std::string &	name
	)

operator<<() [1/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	os,
		const CvdFile &	cvd_file
	)

operator<<() [2/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	os,
		SafeLevel	level
	)

operator<<() [3/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		Arch	arch
	)

operator<<() [4/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const AndroidBuild &	build
	)

operator<<() [5/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const AndroidBuildKey &	key
	)

operator<<() [6/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const AndroidBuilds &	builds
	)

operator<<() [7/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const Build &	build
	)

operator<<() [8/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const BuildArchive &	build_archive
	)

operator<<() [9/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const BuildString &	build_string
	)

operator<<() [10/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const Command &	command
	)

operator<<() [11/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const DeviceBuild &	build
	)

operator<<() [12/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const DeviceBuildString &	build_string
	)

operator<<() [13/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const DirectoryBuild &	build
	)

operator<<() [14/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const DirectoryBuildString &	build_string
	)

operator<<() [15/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const FetchBuildContext &	context
	)

operator<<() [16/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const Flag &	flag
	)

operator<<() [17/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const PrettyContainerType &	pc
	)

operator<<() [18/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const PrettyStruct &	ps
	)

operator<<() [19/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const SnapshotCmd &	cmd
	)

operator<<() [20/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const StackTraceError &	error
	)

operator<<() [21/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const std::optional< BuildString > &	build_string
	)

operator<<() [22/33]

template<typename T >

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const std::vector< T > &	v
	)

operator<<() [23/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		DeviceType	device_type
	)

operator<<() [24/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		ExternalNetworkMode	net
	)

operator<<() [25/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		FileSource	source
	)

operator<<() [26/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		GuestHwuiRenderer	renderer
	)

operator<<() [27/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		GuestRendererPreload	preload
	)

operator<<() [28/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		LauncherResponse	response
	)

operator<<() [29/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		Os	arch
	)

operator<<() [30/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		VmmMode	vmm
	)

operator<<() [31/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	stream,
		const ChromeOsBuilder &	cob
	)

operator<<() [32/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	stream,
		const ChromeOsBuildString &	cb
	)

operator<<() [33/33]

std::ostream & cuttlefish::operator<<	(	std::ostream &	stream,
		const std::optional< ChromeOsBuildString > &	cb
	)

OsCompositeDiskBuilder()

Result< DiskBuilder > cuttlefish::OsCompositeDiskBuilder	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance,
		const std::optional< ChromeOsStateImage > &	chrome_os_state,
		const std::vector< std::unique_ptr< ImageFile > > &	image_files,
		AndroidBuild &	android_build,
		const SystemImageDirFlag &	system_image_dir
	)

OsVersionImpl() [1/2]

static uint32_t cuttlefish::OsVersionImpl ( const boot_img_hdr_v0 &  v0 )

static

OsVersionImpl() [2/2]

static uint32_t cuttlefish::OsVersionImpl ( const boot_img_hdr_v3 &  v3 )

static

OutcomeDereference() [1/4]

template<typename T >

T cuttlefish::OutcomeDereference

(

Result< T > &&

result

)

OutcomeDereference() [2/4]

void cuttlefish::OutcomeDereference ( Result< void > &&  )

inline

OutcomeDereference() [3/4]

template<typename T >

T cuttlefish::OutcomeDereference

(

std::optional< T > &&

value

)

OutcomeDereference() [4/4]

template<typename T >

std::enable_if< std::is_convertible_v< T, bool >, T >::type cuttlefish::OutcomeDereference

(

T &&

value

)

OutputMetrics()

Result< void > cuttlefish::OutputMetrics	(	std::string_view	event_type_label,
		std::string_view	metrics_directory,
		const MetricsData &	metrics_data
	)

OverrideBoolArg()

std::vector< std::string > cuttlefish::OverrideBoolArg	(	std::vector< std::string >	args,
		const std::unordered_set< std::string > &	flag_set
	)

OwnerUid()

Result< uid_t > cuttlefish::OwnerUid

(

const pid_t

pid

)

OwnerUids()

static Result< ProcStatusUids > cuttlefish::OwnerUids ( const pid_t  pid )

static

PackRamdisk()

Result< void > cuttlefish::PackRamdisk	(	const std::string &	ramdisk_stage_dir,
		const std::string &	output_ramdisk
	)

PagePadding() [1/2]

static std::unique_ptr< ReaderSeeker > cuttlefish::PagePadding ( uint64_t  size )

static

PagePadding() [2/2]

static std::unique_ptr< ReaderSeeker > cuttlefish::PagePadding ( uint64_t  size, uint64_t  page_size  )

static

PageSizeImpl() [1/2]

static uint32_t cuttlefish::PageSizeImpl ( const boot_img_hdr_v0 &  v0 )

static

PageSizeImpl() [2/2]

static uint32_t cuttlefish::PageSizeImpl ( const boot_img_hdr_v3 &  )

static

ParentKeyCreator()

std::function< TpmObjectSlot(TpmResourceManager &)> cuttlefish::ParentKeyCreator

(

const std::string &

unique

)

Parse() [1/2]

Result< Parsed > cuttlefish::Parse	(	int	argc,
		char **	argv
	)

Parse() [2/2]

Result< Parsed > cuttlefish::Parse

(

std::vector< std::string > &

args

)

parse_int()

static int cuttlefish::parse_int ( const std::string &  snumber, int  base  )

static

ParseAudioStreamSettings()

cuttlefish::AudioStreamSettings cuttlefish::ParseAudioStreamSettings	(	const ::cuttlefish::config::Audio_PCMDevice_Stream &	stream,
		AudioStreamSettings::Direction	direction
	)

ParseBaseInstanceFlag()

static Result< std::optional< int32_t > > cuttlefish::ParseBaseInstanceFlag ( std::vector< std::string > &  flags )

static

ParseBool()

Result< bool > cuttlefish::ParseBool	(	std::string_view	value,
		std::string_view	name
	)

ParseBuildString()

Result< BuildString > cuttlefish::ParseBuildString

(

std::string_view

build_string

)

ParseChromeOsBuildString()

static Result< ChromeOsBuildString > cuttlefish::ParseChromeOsBuildString ( const std::string &  build_string )

static

ParseCvdConfigs() [1/2]

Result< CvdFlags > cuttlefish::ParseCvdConfigs	(	const cvd::config::EnvironmentSpecification &	env_spec,
		const LocalInstanceGroup &	group
	)

ParseCvdConfigs() [2/2]

Result< CvdFlags > cuttlefish::ParseCvdConfigs	(	const EnvironmentSpecification &	env_spec,
		const LocalInstanceGroup &	group
	)

ParseDeviceType()

DeviceType cuttlefish::ParseDeviceType

(

std::string_view

type_name

)

ParseDisplayConfig()

Result< std::optional< CuttlefishConfig::DisplayConfig > > cuttlefish::ParseDisplayConfig

(

const std::string &

flag

)

ParseDisplayConfigsFromArgs()

Result< std::vector< CuttlefishConfig::DisplayConfig > > cuttlefish::ParseDisplayConfigsFromArgs

(

std::vector< std::string > &

args

)

ParseExternalNetworkMode()

Result< ExternalNetworkMode > cuttlefish::ParseExternalNetworkMode

(

std::string_view

str

)

ParseFetchCvdConfigs() [1/2]

Result< std::vector< std::string > > cuttlefish::ParseFetchCvdConfigs	(	const cvd::config::EnvironmentSpecification &	,
		const std::string &	target_directory,
		const std::vector< std::string > &	target_subdirectories
	)

ParseFetchCvdConfigs() [2/2]

Result< std::vector< std::string > > cuttlefish::ParseFetchCvdConfigs	(	const EnvironmentSpecification &	config,
		const std::string &	target_directory,
		const std::vector< std::string > &	target_subdirectories
	)

ParseGflagsXmlHelp()

Result< std::vector< GflagDescription > > cuttlefish::ParseGflagsXmlHelp

(

std::string_view

xml_help

)

ParseGuestHwuiRenderer()

Result< GuestHwuiRenderer > cuttlefish::ParseGuestHwuiRenderer

(

std::string_view

str

)

ParseGuestRendererPreload()

Result< GuestRendererPreload > cuttlefish::ParseGuestRendererPreload

(

std::string_view

str

)

ParseInstanceNums()

static Result< std::vector< int32_t > > cuttlefish::ParseInstanceNums ( const std::string &  instance_nums_str )

static

ParseInstanceNumsFlag()

static Result< std::vector< int32_t > > cuttlefish::ParseInstanceNumsFlag ( std::vector< std::string > &  flags )

static

ParseInt()

Result< int > cuttlefish::ParseInt	(	const std::string &	value,
		std::string_view	name
	)

ParseJson()

Result< Json::Value > cuttlefish::ParseJson

(

std::string_view

input

)

ParseJsonString()

bool cuttlefish::ParseJsonString	(	std::string &	json_text,
		Json::Value &	root
	)

ParseKernelLine()

Result< KernelLine > cuttlefish::ParseKernelLine

(

std::string_view

line

)

ParseKeyEqualsValue()

Result< std::map< std::string, std::string, std::less< void > > > cuttlefish::ParseKeyEqualsValue

(

const std::string &

contents

)

ParseLaunchCvdConfigs() [1/2]

Result< std::vector< std::string > > cuttlefish::ParseLaunchCvdConfigs

(

cvd::config::EnvironmentSpecification

)

ParseLaunchCvdConfigs() [2/2]

Result< std::vector< std::string > > cuttlefish::ParseLaunchCvdConfigs

(

EnvironmentSpecification

launch

)

ParseLauncherLine()

Result< LauncherLine > cuttlefish::ParseLauncherLine

(

std::string_view

line

)

ParseLogcatLine()

Result< LogcatLine > cuttlefish::ParseLogcatLine

(

std::string_view

line

)

ParseLogTeeLine()

Result< LogTeeLine > cuttlefish::ParseLogTeeLine

(

std::string_view

line

)

ParseMediaConfig()

Result< std::optional< CuttlefishConfig::MediaConfig > > cuttlefish::ParseMediaConfig

(

const std::string &

flag

)

ParseMediaConfigsFromArgs()

Result< std::vector< CuttlefishConfig::MediaConfig > > cuttlefish::ParseMediaConfigsFromArgs

(

std::vector< std::string > &

args

)

ParseNumInstancesFlag()

static Result< std::optional< int32_t > > cuttlefish::ParseNumInstancesFlag ( std::vector< std::string > &  flags )

static

ParseSecureHal()

Result< SecureHal > cuttlefish::ParseSecureHal

(

std::string

mode

)

ParseSecureHals()

Result< std::set< SecureHal > > cuttlefish::ParseSecureHals

(

const std::string &

hals

)

ParseSelectorConfigs() [1/2]

selector::SelectorOptions cuttlefish::ParseSelectorConfigs

(

const cvd::config::EnvironmentSpecification &

)

ParseSelectorConfigs() [2/2]

selector::SelectorOptions cuttlefish::ParseSelectorConfigs

(

const EnvironmentSpecification &

config

)

ParseSemVer()

Result< SemVer > cuttlefish::ParseSemVer

(

std::string_view

str

)

ParseTime()

Result< std::chrono::system_clock::time_point > cuttlefish::ParseTime

(

std::string_view

str

)

ParseTouchpadConfig()

Result< CuttlefishConfig::TouchpadConfig > cuttlefish::ParseTouchpadConfig

(

const std::string &

flag

)

ParseTouchpadConfigsFromArgs()

Result< std::vector< CuttlefishConfig::TouchpadConfig > > cuttlefish::ParseTouchpadConfigsFromArgs

(

std::vector< std::string > &

args

)

ParseVmm()

Result< VmmMode > cuttlefish::ParseVmm

(

std::string_view

str

)

Path()

std::vector< std::string > cuttlefish::Path

(

const std::string &

env_name

)

PerUserCacheDir()

std::string cuttlefish::PerUserCacheDir

(

)

PerUserDir()

std::string cuttlefish::PerUserDir

(

)

PflashPath()

std::string cuttlefish::PflashPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

PhysicalPartitions()

Result< std::unique_ptr< AndroidBuild > > cuttlefish::PhysicalPartitions

(

AndroidBuild &

)

Wrap an AndroidBuild with fallback physical partition detection logic.

If the AndroidBuild does not already provide GPT entry information, this makes a best guess based on known logical partitions and image files.

One use case is the android product directory or m case, where the build system produces a collection of .img files including a super.img, but no explicit list of physical partitions.

Pica()

Result< std::vector< MonitorCommand > > cuttlefish::Pica	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance,
		LogTeeCreator &	log_tee
	)

PicaBinary()

std::string cuttlefish::PicaBinary

(

)

PidDirPath()

static std::string cuttlefish::PidDirPath ( const pid_t  pid )

static

PopulateCuttlefishFetch()

void cuttlefish::PopulateCuttlefishFetch	(	MetricsEventV2 &	event,
		const FetchMetrics &	fetch_metrics
	)

PopulateCuttlefishGuest()

void cuttlefish::PopulateCuttlefishGuest	(	MetricsEventV2 &	metrics_event,
		const GuestMetrics &	guest_metrics,
		std::string_view	session_id
	)

PopulateCuttlefishHost()

void cuttlefish::PopulateCuttlefishHost	(	MetricsEventV2 &	metrics_event,
		const HostMetrics &	host_metrics
	)

Ppid()

Result< pid_t > cuttlefish::Ppid

(

const pid_t

pid

)

PReadExact()

Result< void > cuttlefish::PReadExact	(	const ReaderSeeker &	reader,
		char *	buf,
		size_t	size,
		uint64_t	offset
	)

PReadExactBinary()

template<typename T >

Result< T > cuttlefish::PReadExactBinary	(	const ReaderSeeker &	reader,
		uint64_t	offset
	)

PrepareGrubESP()

EspBuilder cuttlefish::PrepareGrubESP	(	const std::string &	image_path,
		Arch	arch
	)

Pretty() [1/46]

PrettyStruct cuttlefish::Pretty	(	AndroidBuild &	build,
		PrettyAdlPlaceholder
	)

Pretty() [2/46]

PrettyStruct cuttlefish::Pretty	(	AndroidBuilds &	builds,
		PrettyAdlPlaceholder
	)

Pretty() [3/46]

char cuttlefish::Pretty	(	char	value,
		PrettyAdlPlaceholder
	)

Pretty() [4/46]

PrettyStruct cuttlefish::Pretty	(	const android::fs_mgr::Extent &	,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [5/46]

PrettyStruct cuttlefish::Pretty	(	const android::fs_mgr::Interval &	,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [6/46]

PrettyStruct cuttlefish::Pretty	(	const android::fs_mgr::LinearExtent &	,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [7/46]

PrettyStruct cuttlefish::Pretty	(	const android::fs_mgr::LpMetadata &	metadata,
		PrettyAdlPlaceholder
	)

Pretty() [8/46]

PrettyStruct cuttlefish::Pretty	(	const android::fs_mgr::Partition &	,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [9/46]

PrettyStruct cuttlefish::Pretty	(	const android::fs_mgr::PartitionGroup &	,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [10/46]

PrettyStruct cuttlefish::Pretty	(	const android::fs_mgr::ZeroExtent &	,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [11/46]

PrettyStruct cuttlefish::Pretty	(	const AndroidBuildKey &	key,
		PrettyAdlPlaceholder
	)

Pretty() [12/46]

PrettyStruct cuttlefish::Pretty	(	const BuildArchive &	archive,
		PrettyAdlPlaceholder
	)

Pretty() [13/46]

std::string cuttlefish::Pretty	(	const char *const &	value,
		PrettyAdlPlaceholder
	)

Pretty() [14/46]

PrettyStruct cuttlefish::Pretty	(	const Extent &	extent,
		PrettyAdlPlaceholder
	)

Pretty() [15/46]

PrettyStruct cuttlefish::Pretty	(	const GuestConfig &	config,
		PrettyAdlPlaceholder
	)

Pretty() [16/46]

PrettyStruct cuttlefish::Pretty	(	const Interval &	interval,
		PrettyAdlPlaceholder
	)

Pretty() [17/46]

std::string cuttlefish::Pretty	(	const Json::Value &	root,
		PrettyAdlPlaceholder
	)

Pretty() [18/46]

PrettyStruct cuttlefish::Pretty	(	const LinearExtent &	linear_extent,
		PrettyAdlPlaceholder
	)

Pretty() [19/46]

PrettyStruct cuttlefish::Pretty	(	const LpMetadataBlockDevice &	block_device,
		PrettyAdlPlaceholder
	)

Pretty() [20/46]

PrettyStruct cuttlefish::Pretty	(	const LpMetadataExtent &	metadata_extent,
		PrettyAdlPlaceholder
	)

Pretty() [21/46]

PrettyStruct cuttlefish::Pretty	(	const LpMetadataGeometry &	geometry,
		PrettyAdlPlaceholder
	)

Pretty() [22/46]

PrettyStruct cuttlefish::Pretty	(	const LpMetadataHeader &	metadata_header,
		PrettyAdlPlaceholder
	)

Pretty() [23/46]

PrettyStruct cuttlefish::Pretty	(	const LpMetadataPartition &	metadata_partition,
		PrettyAdlPlaceholder
	)

Pretty() [24/46]

PrettyStruct cuttlefish::Pretty	(	const LpMetadataPartitionGroup &	metadata_partition_group,
		PrettyAdlPlaceholder
	)

Pretty() [25/46]

PrettyStruct cuttlefish::Pretty	(	const LpMetadataTableDescriptor &	metadata_table_descriptor,
		PrettyAdlPlaceholder
	)

Pretty() [26/46]

PrettyStruct cuttlefish::Pretty	(	const Partition &	partition,
		PrettyAdlPlaceholder
	)

Pretty() [27/46]

PrettyStruct cuttlefish::Pretty	(	const PartitionGroup &	partition_group,
		PrettyAdlPlaceholder
	)

Pretty() [28/46]

template<typename T >

std::string cuttlefish::Pretty	(	const Result< T > &	result,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [29/46]

template<typename K , typename V , typename Compare >

PrettyContainerType cuttlefish::Pretty	(	const std::map< K, V, Compare > &	map,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [30/46]

template<typename T >

std::string cuttlefish::Pretty	(	const std::optional< T > &	value,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [31/46]

template<typename First , typename Second >

PrettyStruct cuttlefish::Pretty	(	const std::pair< First, Second > &	pair,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [32/46]

template<typename T , typename Comp >

PrettyContainerType cuttlefish::Pretty	(	const std::set< T, Comp > &	set,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [33/46]

std::string cuttlefish::Pretty	(	const std::string &	value,
		PrettyAdlPlaceholder
	)

Pretty() [34/46]

std::string cuttlefish::Pretty	(	const std::string_view &	value,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Strings are quoted to distinguish them from other text.

Pretty() [35/46]

template<typename T >

std::string cuttlefish::Pretty	(	const std::unique_ptr< T > &	value,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [36/46]

template<typename T >

PrettyContainerType cuttlefish::Pretty	(	const std::vector< T > &	vec,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

Pretty() [37/46]

template<typename T >

const T & cuttlefish::Pretty	(	const T &	value,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

This is the fallback pretty-printing case: if abseil can print the value, have abseil do it.

This function is intended to be overloaded. Overloads for common types are in this directory, but other types can also define their own overloads.

Not all overloads will return std::string. The returned type should be formattable by abseil, libfmt, and ostreams. This allows deferring formatting to avoid allocating fewer intermediate strings.

If a type defines both a cuttlefish::Pretty overload and an AbslStringify hook, the cuttlefish::Pretty implementation is preferred by overload resolution as it is a more specific type. However, if the cuttlefish::Pretty overload is defined in a different header, the presence of the header affects which overloads are in scope, so leaving the header include out could still compile but unintentionally refer to this default fallback. Therefore, cuttlefish::Pretty overloads should be declared together with the header.

Worse than that, the PrettyAdlPlaceHolder() hack is there to trigger argument-dependent lookup within namespace cuttlefish: otherwise the Pretty overloads for non-namespace cuttlefish types will only be detected based on declaration order through standard name lookup rules. Having an argument type declared within namespace cuttlefish forces it to search the entire namespace rather than only declarations defined earlier in the translation unit. This is relevant for Pretty invocations within PrettyContainer and PrettyStruct.

Pretty() [38/46]

PrettyStruct cuttlefish::Pretty	(	const ZeroExtent &	zero_extent,
		PrettyAdlPlaceholder
	)

Pretty() [39/46]

int16_t cuttlefish::Pretty	(	int16_t	value,
		PrettyAdlPlaceholder
	)

Pretty() [40/46]

int32_t cuttlefish::Pretty	(	int32_t	value,
		PrettyAdlPlaceholder
	)

Pretty() [41/46]

int64_t cuttlefish::Pretty	(	int64_t	value,
		PrettyAdlPlaceholder
	)

Pretty() [42/46]

int8_t cuttlefish::Pretty	(	int8_t	,
		PrettyAdlPlaceholder	unused = PrettyAdlPlaceholder()
	)

The standard says that accessing unaligned values by reference is undefined behavior. These overloads of cuttlefish::Pretty capture calls that use numeric values and pass them by value rather than the default pass-by-reference fallback defined in pretty.h. This is because numeric values are likely to appear in __attribute__((packed)) structs which can have unaligned values.

Pretty() [43/46]

uint16_t cuttlefish::Pretty	(	uint16_t	value,
		PrettyAdlPlaceholder
	)

Pretty() [44/46]

uint32_t cuttlefish::Pretty	(	uint32_t	value,
		PrettyAdlPlaceholder
	)

Pretty() [45/46]

uint64_t cuttlefish::Pretty	(	uint64_t	value,
		PrettyAdlPlaceholder
	)

Pretty() [46/46]

uint8_t cuttlefish::Pretty	(	uint8_t	value,
		PrettyAdlPlaceholder
	)

PrettyContainer() [1/2]

template<typename T >

PrettyContainerType cuttlefish::PrettyContainer

(

const T &

container

)

PrettyContainer() [2/2]

template<typename T , typename FmtMemberFn >

PrettyContainerType cuttlefish::PrettyContainer	(	const T &	container,
		FmtMemberFn	format_member_fn
	)

PrettyIterable() [1/2]

template<typename Iterator , typename FmtIteratorFn >

PrettyContainerType cuttlefish::PrettyIterable	(	Iterator	begin,
		Iterator	end
	)

PrettyIterable() [2/2]

template<typename Iterator , typename FmtIteratorFn >

PrettyContainerType cuttlefish::PrettyIterable	(	Iterator	begin,
		Iterator	end,
		FmtIteratorFn	format_iterator_fn
	)

ProcessFlags()

Result< MetricsFlags > cuttlefish::ProcessFlags	(	int	argc,
		char **	argv
	)

ProcessRestarterBinary()

std::string cuttlefish::ProcessRestarterBinary

(

)

ProtectiveMbr()

MasterBootRecord cuttlefish::ProtectiveMbr

(

uint64_t

size

)

Creates a "Protective" MBR Partition Table header. The GUID Partition Table Specification recommends putting this on the first sector of the disk, to protect against old disk formatting tools from misidentifying the GUID Partition Table later and doing the wrong thing.

Proxy()

void cuttlefish::Proxy	(	SharedFD	server,
		std::function< SharedFD()>	conn_factory
	)

ProxyAsync()

std::unique_ptr< ProxyServer > cuttlefish::ProxyAsync	(	SharedFD	server,
		std::function< SharedFD()>	conn_factory
	)

PruneCache()

Result< PruneResult > cuttlefish::PruneCache	(	const std::string &	cache_directory,
		const size_t	allowed_size_gb
	)

PruneLogsDirectory()

Result< void > cuttlefish::PruneLogsDirectory	(	const std::string &	log_dir = CvdUserLogDir(),
		size_t	retain = kCvdRetainLogFilesNum
	)

Prunes the logs directory keeping only the most recent log files.

PstorePath()

std::string cuttlefish::PstorePath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

PushInterruptListener()

Result< std::unique_ptr< InterruptListenerHandle > > cuttlefish::PushInterruptListener

(

InterruptListener

listener

)

Allows reacting to interrupt-like signals (SIGINT, SIGHUP, SIGTERM). A global stack of interrupt listeners is maintained. When an interrupt signal is received the listener at top of the stack is executed. Returns an object that, when destroyed, disables the listener at the top of the stack, re-enabling the previous one. This function is not thread-safe and shouldn't be called from multiple threads, not even with synchronization. The listeners are executed in a background thread, not in the actual interrupt handler. It's ok to run blocking code in that thread, but disabling the listener may wait for the thread to finish executing, so if the code in the listener could wait for the thread that disables it a deadlock may occur. Similarly, disabling the listener from inside the listener will lead to a deadlock. The listener is given the actual signal received, one of SIGINT, SIGHUP or SIGTERM. To disable the listener (pop it from the listener stack) just destroy the returned handle.

RamdiskSize() [1/2]

static uint32_t cuttlefish::RamdiskSize ( const boot_img_hdr_v0 &  v0 )

static

RamdiskSize() [2/2]

static uint32_t cuttlefish::RamdiskSize ( const boot_img_hdr_v3 &  v3 )

static

RandomSerialNumber()

std::string cuttlefish::RandomSerialNumber

(

const std::string &

prefix

)

ReadAll()

static Result< std::string > cuttlefish::ReadAll ( const std::string &  file_path )

static

ReadAllFDData()

std::string cuttlefish::ReadAllFDData

(

SharedFD

fd

)

ReadAndroidVersionFromBootImage()

Result< std::string > cuttlefish::ReadAndroidVersionFromBootImage

(

const std::string &

boot_image_path

)

ReadCvdDataFile()

Result< std::string > cuttlefish::ReadCvdDataFile

(

std::string_view

path

)

ReadExact() [1/4]

Result< void > cuttlefish::ReadExact	(	Reader &	reader,
		char *	buf,
		size_t	size
	)

ReadExact() [2/4]

ssize_t cuttlefish::ReadExact	(	SharedFD	fd,
		char *	buf,
		size_t	size
	)

Reads from fd until reading size bytes or errors.

On a successful read, returns buf->size().

If a read error is encountered, returns -1. buf will contain any data read up until that point and errno will be set.

When the size is 0, read(fd, buf, 0) is effectively called, which means error(s) might be detected. If detected, the return value would be -1. If not detected, the return value will be 0.

ReadExact() [3/4]

ssize_t cuttlefish::ReadExact	(	SharedFD	fd,
		std::string *	buf
	)

Reads from fd until reading buf->size() bytes or errors.

On a successful read, returns buf->size().

If a read error is encountered, returns -1. buf will contain any data read up until that point and errno will be set.

If the size of buf is 0, read(fd, buf, 0) is effectively called, which means error(s) might be detected. If detected, the return value would be -1. If not detected, the return value will be 0.

ReadExact() [4/4]

ssize_t cuttlefish::ReadExact	(	SharedFD	fd,
		std::vector< char > *	buf
	)

Reads from fd until reading buf->size() bytes or errors.

On a successful read, returns buf->size().

If a read error is encountered, returns -1. buf will contain any data read up until that point and errno will be set.

If the size of buf is 0, read(fd, buf, 0) is effectively called, which means error(s) might be detected. If detected, the return value would be -1. If not detected, the return value will be 0.

ReadExactBinary() [1/2]

template<typename T >

Result< T > cuttlefish::ReadExactBinary

(

Reader &

reader

)

ReadExactBinary() [2/2]

template<typename T >

ssize_t cuttlefish::ReadExactBinary	(	SharedFD	fd,
		T *	binary_data
	)

ReadExactBinaryOrEof()

template<typename T >

Result< std::optional< T > > cuttlefish::ReadExactBinaryOrEof

(

Reader &

reader

)

ReadExactOrEof()

Result< bool > cuttlefish::ReadExactOrEof	(	Reader &	reader,
		char *	buf,
		size_t	size
	)

ReadExitCode()

Result< RunnerExitCodes > cuttlefish::ReadExitCode

(

SharedFD

monitor_socket

)

ReadFile()

std::string cuttlefish::ReadFile

(

const std::string &

file

)

ReadFileContents()

Result< std::string > cuttlefish::ReadFileContents

(

const std::string &

path

)

ReadGuestConfig()

Result< std::vector< GuestConfig > > cuttlefish::ReadGuestConfig	(	const BootImageFlag &	boot_image,
		const KernelPathFlag &	kernel_path,
		const SystemImageDirFlag &	system_image_dirs
	)

ReadLauncherActionFromFd()

Result< std::optional< LauncherActionInfo > > cuttlefish::ReadLauncherActionFromFd

(

SharedFD

monitor_socket

)

ReadLink() [1/3]

Result< std::string > cuttlefish::ReadLink

(

const char *

path

)

ReadLink() [2/3]

Result< std::string > cuttlefish::ReadLink

(

const std::string &

path

)

ReadLink() [3/3]

Result< std::string > cuttlefish::ReadLink

(

std::string_view

path

)

ReadProtectedJsonFromFile()

Json::Value cuttlefish::ReadProtectedJsonFromFile	(	TpmResourceManager &	resource_manager,
		const std::string &	filename
	)

ReadSessionIdFile()

Result< std::string > cuttlefish::ReadSessionIdFile

(

const std::string &

metrics_directory

)

ReadToString() [1/2]

Result< std::string > cuttlefish::ReadToString

(

ReadableZipSource &

source

)

ReadToString() [2/2]

Result< std::string > cuttlefish::ReadToString	(	Reader &	reader,
		size_t	buffer_size
	)

RealPath()

Result< std::string > cuttlefish::RealPath

(

const std::string &

path

)

RebuildSuperImageIfNecessary()

Result< void > cuttlefish::RebuildSuperImageIfNecessary	(	const FetcherConfig &	fetcher_config,
		const CuttlefishConfig::InstanceSpecific &	instance
	)

RecordToStorageData()

static Result< secure_env::ManagedStorageData > cuttlefish::RecordToStorageData ( const gatekeeper::failure_record_t &  record )

static

RecursivelyRemoveDirectory()

Result< void > cuttlefish::RecursivelyRemoveDirectory

(

const std::string &

path

)

RecvAll()

Result< std::string > cuttlefish::RecvAll	(	Fd &	sock,
		uint64_t	count
	)

Receives 'count' bytes from sock, checking for socket error conditions

On successful Recv, returns a string containing the received data

RemoveFile() [1/3]

Result< void > cuttlefish::RemoveFile

(

const char *

file

)

RemoveFile() [2/3]

Result< void > cuttlefish::RemoveFile

(

const std::string &

file

)

RemoveFile() [3/3]

Result< void > cuttlefish::RemoveFile

(

std::string_view

file

)

Rename() [1/3]

Result< void > cuttlefish::Rename	(	const char *	oldpath,
		const char *	newpath
	)

Rename() [2/3]

Result< void > cuttlefish::Rename	(	const std::string &	oldpath,
		const std::string &	newpath
	)

Rename() [3/3]

Result< void > cuttlefish::Rename	(	std::string_view	oldpath,
		std::string_view	newpath
	)

RenameFile()

Result< std::string > cuttlefish::RenameFile	(	const std::string &	current_filepath,
		const std::string &	target_filepath
	)

RepackBootImage()

Result< void > cuttlefish::RepackBootImage	(	const std::string &	new_kernel_path,
		const std::string &	boot_image_path,
		const std::string &	new_boot_image_path
	)

RepackGem5BootImage()

Result< void > cuttlefish::RepackGem5BootImage	(	const std::string &	initrd_path,
		const std::optional< BootConfigPartition > &	bootconfig_partition,
		const std::string &	unpack_dir,
		const std::string &	input_ramdisk_path
	)

RepackKernelRamdisk()

Result< void > cuttlefish::RepackKernelRamdisk	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance
	)

RepackSuperWithPartition()

Result< void > cuttlefish::RepackSuperWithPartition	(	const std::string &	superimg_path,
		const std::string &	image_path,
		const std::string &	partition_name
	)

RepackVendorBootImage()

Result< void > cuttlefish::RepackVendorBootImage	(	const std::string &	new_ramdisk,
		const std::string &	vendor_boot_image_path,
		const std::string &	new_vendor_boot_image_path,
		const std::string &	unpack_dir,
		bool	bootconfig_supported
	)

RepackVendorBootImageWithEmptyRamdisk()

Result< void > cuttlefish::RepackVendorBootImageWithEmptyRamdisk	(	const std::string &	vendor_boot_image_path,
		const std::string &	new_vendor_boot_image_path,
		const std::string &	unpack_dir,
		bool	bootconfig_supported
	)

RequestHandler()

Result< CvdCommandHandler * > cuttlefish::RequestHandler	(	const CommandRequest &	request,
		const std::vector< std::unique_ptr< CvdCommandHandler > > &	handlers
	)

RequiredDirectories()

std::vector< std::string > cuttlefish::RequiredDirectories

(

const CuttlefishConfig &

config

)

ResolveInstanceFiles()

Result< void > cuttlefish::ResolveInstanceFiles	(	const BootImageFlag &	boot_image,
		const InitramfsPathFlag &	initramfs_path,
		const KernelPathFlag &	kernel_path,
		const SuperImageFlag &	super_image,
		const SystemImageDirFlag &	system_image_dir,
		const VendorBootImageFlag &	vendor_boot_image
	)

RestoreAdbdPipeName()

std::string cuttlefish::RestoreAdbdPipeName

(

const CuttlefishConfig::InstanceSpecific &

ins

)

ResultErrorFormat()

std::string cuttlefish::ResultErrorFormat

(

bool

color

)

ResultInstanceFlag()

template<typename T >

Result< std::string > cuttlefish::ResultInstanceFlag	(	const std::string &	name,
		const cvd::config::EnvironmentSpecification &	config,
		T	callback
	)

RetryingServerErrorHttpClient()

std::unique_ptr< HttpClient > cuttlefish::RetryingServerErrorHttpClient	(	HttpClient &	inner,
		int	retry_attempts,
		std::chrono::milliseconds	retry_delay
	)

RootCanalBinary()

std::string cuttlefish::RootCanalBinary

(

)

RootCanalComponent()

fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific, LogTeeCreator > > cuttlefish::RootCanalComponent

(

)

RotaryCaptureServerPath()

std::string cuttlefish::RotaryCaptureServerPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

RotaryEventsServerPath()

std::string cuttlefish::RotaryEventsServerPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

RotarySocketPath()

std::string cuttlefish::RotarySocketPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

RoundUpToBlockSize()

static uint32_t cuttlefish::RoundUpToBlockSize ( uint32_t  num )

static

RunAndCaptureStdout()

Result< std::string > cuttlefish::RunAndCaptureStdout

(

Command

command

)

RunCvdMain()

Result< void > cuttlefish::RunCvdMain	(	int	argc,
		char **	argv
	)

RunExternalCommand()

int cuttlefish::RunExternalCommand

(

const std::string &

command

)

RunLauncherAction() [1/2]

Result< void > cuttlefish::RunLauncherAction	(	SharedFD	monitor_socket,
		const run_cvd::ExtendedLauncherAction &	extended_action,
		std::optional< int >	timeout_seconds
	)

RunLauncherAction() [2/2]

Result< void > cuttlefish::RunLauncherAction	(	SharedFD	monitor_socket,
		LauncherAction	action,
		std::optional< int >	timeout_seconds
	)

RunLogin()

Result< void > cuttlefish::RunLogin

(

)

RunStopCvd()

Result< void > cuttlefish::RunStopCvd

(

StopCvdParams

params

)

–clear_instance_dirs or –instance_nums may not be available in old branches. This causes stop_cvd to terminate with a non-zero exit code due to a parsing error. Try again without that flag.

RunWithManagedStdio()

int cuttlefish::RunWithManagedStdio	(	Command	cmd_tmp,
		const std::string *	stdin_str,
		std::string *	stdout_str,
		std::string *	stderr_str,
		SubprocessOptions	options
	)

ScreenRecordingServer()

Result< std::optional< MonitorCommand > > cuttlefish::ScreenRecordingServer

(

GrpcSocketCreator &

grpc_socket

)

ScreenRecordingServerBinary()

std::string cuttlefish::ScreenRecordingServerBinary

(

)

ScrubSecrets()

std::string cuttlefish::ScrubSecrets

(

const std::string &

data

)

ScrubUrl()

std::string cuttlefish::ScrubUrl

(

std::string_view

url

)

Search()

Result< std::string > cuttlefish::Search	(	const std::vector< std::string > &	path,
		std::string_view	name
	)

SecureEnv()

Result< MonitorCommand > cuttlefish::SecureEnv	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance,
		AutoSnapshotControlFiles::Type &	snapshot_control_files,
		KernelLogPipeProvider &	kernel_log_pipe_provider
	)

SecureEnvBinary()

std::string cuttlefish::SecureEnvBinary

(

)

SecureEnvMain()

Result< void > cuttlefish::SecureEnvMain	(	int	argc,
		char **	argv
	)

SegmentedHmac()

static UniqueEsysPtr< TPM2B_DIGEST > cuttlefish::SegmentedHmac ( TpmResourceManager &  resource_manager, ESYS_TR  key_handle, TpmAuth  key_auth, const uint8_t *  data, size_t  data_size  )

static

Select()

int cuttlefish::Select	(	SharedFDSet *	read_set,
		SharedFDSet *	write_set,
		SharedFDSet *	error_set,
		struct timeval *	timeout
	)

SharedFD version of select.

read_set, write_set, and timeout are in/out parameters. This caller should keep a copy of the original values if it wants to preserve them.

SendAll()

bool cuttlefish::SendAll	(	SharedFD	sock,
		std::string_view	msg
	)

Sends contents of msg through sock, checking for socket error conditions

On successful Send, returns true

If a Send error is encountered, returns false. Some data may have already been written to 'sock' at that point.

SendSignalImpl()

static Result< void > cuttlefish::SendSignalImpl ( const int  signal, const pid_t  pid, bool  to_group, const bool  started  )

static

SensorsSimulator()

Result< MonitorCommand > cuttlefish::SensorsSimulator	(	const CuttlefishConfig::InstanceSpecific &	instance,
		AutoSensorsSocketPair::Type &	sensors_socket_pair,
		KernelLogPipeProvider &	kernel_log_pipe_provider
	)

SensorsSimulatorBinary()

std::string cuttlefish::SensorsSimulatorBinary

(

)

SerializableToKeyBlob()

static KeymasterKeyBlob cuttlefish::SerializableToKeyBlob ( const Serializable &  serializable )

static

Serialize()

std::string cuttlefish::Serialize

(

const DisjointRangeSet &

range_set

)

SerializeKeyEqualsValue() [1/2]

std::string cuttlefish::SerializeKeyEqualsValue

(

const std::map< std::string, std::string > &

key_equals_value

)

SerializeKeyEqualsValue() [2/2]

std::string cuttlefish::SerializeKeyEqualsValue

(

const std::map< std::string, std::string, std::less< void > > &

key_equals_value

)

serverLoopComponent()

fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific, AutoSnapshotControlFiles::Type, WebRtcController >, ServerLoop > cuttlefish::serverLoopComponent

(

)

SetDefaultFlagsForCrosvm()

Result< void > cuttlefish::SetDefaultFlagsForCrosvm	(	const SystemImageDirFlag &	system_image_dir,
		const std::vector< GuestConfig > &	guest_configs,
		std::map< std::string, std::string > &	name_to_default_value
	)

SetDefaultFlagsForGem5()

void cuttlefish::SetDefaultFlagsForGem5

(

)

SetDefaultFlagsForOpenwrt()

void cuttlefish::SetDefaultFlagsForOpenwrt

(

Arch

target_arch

)

SetFilepath()

void cuttlefish::SetFilepath	(	BuildString &	build_string,
		const std::string &	value
	)

SetFlagDefaultsForVmm()

Result< void > cuttlefish::SetFlagDefaultsForVmm	(	const std::vector< GuestConfig > &	guest_configs,
		const SystemImageDirFlag &	system_image_dir,
		const VmManagerFlag &	vm_manager_flag
	)

SetLoggers()

void cuttlefish::SetLoggers	(	std::vector< SeverityTarget >	destinations,
		const std::string &	log_prefix
	)

SetStatus()

static Result< void > cuttlefish::SetStatus ( SharedFD &  fd, const InUseState  state  )

static

SetupAudio()

std::shared_ptr< AudioHandler > cuttlefish::SetupAudio	(	const cuttlefish::CuttlefishConfig::InstanceSpecific &	instance,
		cuttlefish::webrtc_streaming::Streamer &	streamer
	)

SetupBridgeGateway()

bool cuttlefish::SetupBridgeGateway	(	std::string_view	bridge_name,
		std::string_view	ipaddr
	)

SetupFeatureDeps()

template<typename... Args>

std::unordered_set< SetupFeature * > cuttlefish::SetupFeatureDeps

(

const std::tuple< Args... > &

args

)

SetUpMetrics()

Result< void > cuttlefish::SetUpMetrics

(

const std::string &

metrics_directory

)

SetupWizardMode()

static Result< std::string > cuttlefish::SetupWizardMode ( const Instance &  instance )

static

SharedFDFlag()

Flag cuttlefish::SharedFDFlag	(	const std::string &	name,
		SharedFD &	out
	)

ShouldAutoLogin()

Result< bool > cuttlefish::ShouldAutoLogin

(

const BuildApiFlags &

flags

)

ShouldColorStderr()

bool cuttlefish::ShouldColorStderr

(

)

ShouldColorStdout()

bool cuttlefish::ShouldColorStdout

(

)

ShouldEnableMultitouch()

bool cuttlefish::ShouldEnableMultitouch

(

const CuttlefishConfig::InstanceSpecific &

instance

)

ShutdownIface()

Result< void > cuttlefish::ShutdownIface

(

std::string_view

name

)

SigningKeyCreator()

std::function< TpmObjectSlot(TpmResourceManager &)> cuttlefish::SigningKeyCreator

(

const std::string &

unique

)

Simg2ImgBinary()

std::string cuttlefish::Simg2ImgBinary

(

)

SimpleMediaDevice()

static bool cuttlefish::SimpleMediaDevice ( const Instance &  instance )

static

SnapshotMetaJsonPath()

std::string cuttlefish::SnapshotMetaJsonPath

(

const std::string &

snapshot_path

)

SocketVsockProxyBinary()

std::string cuttlefish::SocketVsockProxyBinary

(

)

SourceEnumToString()

std::string_view cuttlefish::SourceEnumToString

(

FileSource

source

)

SourceStringToEnum()

FileSource cuttlefish::SourceStringToEnum

(

std::string_view

source

)

SparseCopy()

Result< void > cuttlefish::SparseCopy	(	Reader &	reader,
		WriterSeeker &	writer,
		size_t	buffer_size
	)

SparseFileSizes()

FileSizes cuttlefish::SparseFileSizes

(

const std::string &

path

)

SplitEnforcedProperties()

static keymaster_error_t cuttlefish::SplitEnforcedProperties ( const keymaster::AuthorizationSet &  key_description, keymaster::AuthorizationSet *  hw_enforced, keymaster::AuthorizationSet *  sw_enforced, keymaster::AuthorizationSet *  hidden  )

static

Distinguish what properties the secure_env implementation handles. If secure_env handles it, the property is put in hw_enforced. Otherwise, the property is put in sw_enforced, and the Keystore process inside Android will try to enforce the property.

SplitRamdiskModules()

Result< void > cuttlefish::SplitRamdiskModules	(	const std::string &	ramdisk_path,
		const std::string &	ramdisk_stage_dir,
		const std::string &	vendor_dlkm_build_dir,
		const std::string &	system_dlkm_build_dir
	)

StartDnsmasq()

bool cuttlefish::StartDnsmasq	(	std::string_view	bridge_name,
		std::string_view	gateway,
		std::string_view	dhcp_range
	)

StartScreenRecording()

Result< void > cuttlefish::StartScreenRecording	(	const CuttlefishConfig::InstanceSpecific &	instance_config,
		std::chrono::seconds	wait_for_launcher
	)

Stat() [1/3]

Result< struct stat > cuttlefish::Stat

(

const char *

path

)

Stat() [2/3]

Result< struct stat > cuttlefish::Stat

(

const std::string &

path

)

Stat() [3/3]

Result< struct stat > cuttlefish::Stat

(

std::string_view

path

)

StopCvdBinary()

std::string cuttlefish::StopCvdBinary

(

)

StopDnsmasq()

bool cuttlefish::StopDnsmasq

(

std::string_view

name

)

StopModemSimulator()

static StopperResult cuttlefish::StopModemSimulator ( int  id )

static

StopScreenRecording()

Result< void > cuttlefish::StopScreenRecording	(	const CuttlefishConfig::InstanceSpecific &	instance_config,
		std::chrono::seconds	wait_for_launcher
	)

StorageDataToRecord()

static Result< gatekeeper::failure_record_t > cuttlefish::StorageDataToRecord ( const secure_env::StorageData &  data )

static

StrError()

std::string cuttlefish::StrError

(

int

error_num

)

StringFromEnv() [1/6]

std::optional< std::string > cuttlefish::StringFromEnv

(

const char *

varname

)

StringFromEnv() [2/6]

std::string cuttlefish::StringFromEnv	(	const char *	varname,
		const std::string &	defval
	)

StringFromEnv() [3/6]

std::optional< std::string > cuttlefish::StringFromEnv

(

const std::string &

varname

)

StringFromEnv() [4/6]

std::string cuttlefish::StringFromEnv	(	const std::string &	varname,
		const std::string &	defval
	)

StringFromEnv() [5/6]

std::optional< std::string > cuttlefish::StringFromEnv

(

std::string_view

varname

)

StringFromEnv() [6/6]

std::string cuttlefish::StringFromEnv	(	std::string_view	varname,
		const std::string &	defval
	)

StringFromGlobalGflags()

Result< FromGflags< std::string > > cuttlefish::StringFromGlobalGflags	(	const gflags::CommandLineFlagInfo &	flag_info,
		const std::string &	flag_name
	)

StringToAdbMode()

AdbMode cuttlefish::StringToAdbMode

(

std::string_view

mode

)

StripColorCodes()

std::string cuttlefish::StripColorCodes

(

const std::string &

str

)

SuperImageAsBuild()

Result< std::unique_ptr< AndroidBuild > > cuttlefish::SuperImageAsBuild

(

AndroidBuild &

build

)

SuperImageNeedsRebuilding()

Result< bool > cuttlefish::SuperImageNeedsRebuilding	(	const FetcherConfig &	fetcher_config,
		const std::string &	default_target_zip,
		const std::string &	system_target_zip
	)

SwitchesCaptureServerPath()

std::string cuttlefish::SwitchesCaptureServerPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

SwitchesEventsServerPath()

std::string cuttlefish::SwitchesEventsServerPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

SwitchesSocketPath()

std::string cuttlefish::SwitchesSocketPath

(

const CuttlefishConfig::InstanceSpecific &

ins

)

Symlink()

Result< void > cuttlefish::Symlink	(	const std::string &	target,
		const std::string &	linkpath
	)

SymlinkHostPackage()

Result< void > cuttlefish::SymlinkHostPackage

(

const std::string &

target_dir

)

SystemWideUserHome()

Result< std::string > cuttlefish::SystemWideUserHome

(

)

returns the user's home defined by the system

This is done not by using HOME but by calling getpwuid(getuid())

TargetFiles() [1/2]

Result< std::unique_ptr< AndroidBuild > > cuttlefish::TargetFiles	(	const FetcherConfig &	,
		FileSource
	)

Finds Android build artifacts from a -target_files- zip file downloaded and possibly extracted by cvd fetch.

TargetFiles() [2/2]

Result< std::unique_ptr< AndroidBuild > > cuttlefish::TargetFiles

(

const std::string &

path

)

Finds android build artifacts from a -target_files- zip file that is present in a directory, likely the out/dist directory of a local Android build.

TcpConnectorBinary()

std::string cuttlefish::TcpConnectorBinary

(

)

TempDir()

std::string cuttlefish::TempDir

(

)

TEST() [1/281]

cuttlefish::TEST	(	AdbConfigTest	,
		SerializeDeserialize
	)

TEST() [2/281]

cuttlefish::TEST	(	AdbConfigTest	,
		SetFromFlags
	)

TEST() [3/281]

cuttlefish::TEST	(	Base64Test	,
		DecodeMult3
	)

TEST() [4/281]

cuttlefish::TEST	(	Base64Test	,
		DecodeNonMult3
	)

TEST() [5/281]

cuttlefish::TEST	(	Base64Test	,
		DecodeStringViewSubstring
	)

TEST() [6/281]

cuttlefish::TEST	(	Base64Test	,
		EncodeMult3
	)

TEST() [7/281]

cuttlefish::TEST	(	Base64Test	,
		EncodeNonMult3
	)

TEST() [8/281]

cuttlefish::TEST	(	Base64Test	,
		EncodeOneZero
	)

TEST() [9/281]

cuttlefish::TEST	(	Base64Test	,
		EncodeThreeZeroes
	)

TEST() [10/281]

cuttlefish::TEST	(	Base64Test	,
		EncodeTwoZeroes
	)

TEST() [11/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseNetSimArgs
	)

TEST() [12/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseNetSimArgsWhitespaceError
	)

TEST() [13/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseNetSimFlagEmptyJson
	)

TEST() [14/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseNetSimFlagEnabled
	)

TEST() [15/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesAutoTabletDisplaysFlag
	)

TEST() [16/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBlankDataImageEmptyJson
	)

TEST() [17/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBlankDataImageFullJson
	)

TEST() [18/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBlankDataImagePartialJson
	)

TEST() [19/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBootAnimationFlagEmptyJson
	)

TEST() [20/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBootAnimationFlagFullJson
	)

TEST() [21/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBootAnimationFlagPartialJson
	)

TEST() [22/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesDisplaysFlagEmptyDisplays
	)

TEST() [23/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesDisplaysFlagEmptyGraphics
	)

TEST() [24/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesDisplaysFlagEmptyJson
	)

TEST() [25/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesEnforceSecurityFlagEmptyJson
	)

TEST() [26/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesEnforceSecurityFlagFullJson
	)

TEST() [27/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesEnforceSecurityFlagPartialJson
	)

TEST() [28/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesSerialNumberFlagEmptyJson
	)

TEST() [29/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesSerialNumberFlagFullJson
	)

TEST() [30/281]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesSerialNumberFlagPartialJson
	)

TEST() [31/281]

cuttlefish::TEST	(	BuildStringGflagsCompatFlagTests	,
		EmptyInputEmptyResultSuccess
	)

TEST() [32/281]

cuttlefish::TEST	(	BuildStringGflagsCompatFlagTests	,
		MultiEmptyValueSuccess
	)

TEST() [33/281]

cuttlefish::TEST	(	BuildStringGflagsCompatFlagTests	,
		MultiValueMixedWithEmptySuccess
	)

TEST() [34/281]

cuttlefish::TEST	(	BuildStringGflagsCompatFlagTests	,
		MultiValueSuccess
	)

TEST() [35/281]

cuttlefish::TEST	(	ConfigFlagsParserTest	,
		ParseMultiInstanceConfig
	)

TEST() [36/281]

cuttlefish::TEST	(	ConfigFlagsParserTest	,
		ParseMultiInstanceConfigPartial
	)

TEST() [37/281]

cuttlefish::TEST	(	ConfigFlagsParserTest	,
		ParseSingleInstanceConfig
	)

TEST() [38/281]

cuttlefish::TEST	(	ConnectivityFlagsParserTest	,
		ParseModemSimulatorSimTypeInvalidInt
	)

TEST() [39/281]

cuttlefish::TEST	(	ConnectivityFlagsParserTest	,
		ParseModemSimulatorSimTypeInvalidString
	)

TEST() [40/281]

cuttlefish::TEST	(	ConnectivityFlagsParserTest	,
		ParseModemSimulatorSimTypeUnspecified
	)

TEST() [41/281]

cuttlefish::TEST	(	ConnectivityFlagsParserTest	,
		ParseModemSimulatorSimTypeValidInt
	)

TEST() [42/281]

cuttlefish::TEST	(	ConnectivityFlagsParserTest	,
		ParseModemSimulatorSimTypeValidString
	)

TEST() [43/281]

cuttlefish::TEST	(	CvdFlagTest	,
		FlagProxyFilter
	)

TEST() [44/281]

cuttlefish::TEST	(	CvdLoadFlagsTest	,
		CredentialSourceConflictWithOverride
	)

TEST() [45/281]

cuttlefish::TEST	(	CvdLoadFlagsTest	,
		CredentialSourceDuplicated
	)

TEST() [46/281]

cuttlefish::TEST	(	CvdLoadFlagsTest	,
		CredentialSourceGetter
	)

TEST() [47/281]

cuttlefish::TEST	(	CvdLoadFlagsTest	,
		CredentialSourceSetter
	)

TEST() [48/281]

cuttlefish::TEST	(	CvdLoadFlagsTest	,
		DuplicateOverridesFail
	)

TEST() [49/281]

cuttlefish::TEST	(	CvdLoadFlagsTest	,
		OverrideConflictWithCredentialSource
	)

TEST() [50/281]

cuttlefish::TEST	(	CvdLoadFlagsTest	,
		OverrideConflictWithProjectID
	)

TEST() [51/281]

cuttlefish::TEST	(	CvdLoadFlagsTest	,
		ProjectIDConflictWithOverride
	)

TEST() [52/281]

cuttlefish::TEST	(	CvdLoadFlagsTest	,
		ProjectIDDuplicated
	)

TEST() [53/281]

cuttlefish::TEST	(	CvdLoadFlagsTest	,
		ProjectIDGetter
	)

TEST() [54/281]

cuttlefish::TEST	(	CvdLoadFlagsTest	,
		ProjectIDSetter
	)

TEST() [55/281]

cuttlefish::TEST	(	DisplayConfigTest	,
		ParseProto
	)

TEST() [56/281]

cuttlefish::TEST	(	EnvironmentTest	,
		StringFromEnvCharPtr
	)

TEST() [57/281]

cuttlefish::TEST	(	EnvironmentTest	,
		StringFromEnvCharPtrDefault
	)

TEST() [58/281]

cuttlefish::TEST	(	EnvironmentTest	,
		StringFromEnvCharPtrDefaultFallback
	)

TEST() [59/281]

cuttlefish::TEST	(	EnvironmentTest	,
		StringFromEnvString
	)

TEST() [60/281]

cuttlefish::TEST	(	EnvironmentTest	,
		StringFromEnvStringDefault
	)

TEST() [61/281]

cuttlefish::TEST	(	EnvironmentTest	,
		StringFromEnvStringDefaultFallback
	)

TEST() [62/281]

cuttlefish::TEST	(	EnvironmentTest	,
		StringFromEnvStringView
	)

TEST() [63/281]

cuttlefish::TEST	(	EnvironmentTest	,
		StringFromEnvStringViewDefault
	)

TEST() [64/281]

cuttlefish::TEST	(	EnvironmentTest	,
		StringFromEnvStringViewDefaultFallback
	)

TEST() [65/281]

cuttlefish::TEST	(	FakeHttpClientTest	,
		ChoosesUrl
	)

TEST() [66/281]

cuttlefish::TEST	(	FakeHttpClientTest	,
		InvokesCallback
	)

TEST() [67/281]

cuttlefish::TEST	(	FakeHttpClientTest	,
		NoMatchingUrl
	)

TEST() [68/281]

cuttlefish::TEST	(	FakeHttpClientTest	,
		WithoutUrlMatching
	)

TEST() [69/281]

cuttlefish::TEST	(	FetchConfigParserTests	,
		AndroidEfiLoaderBuildOnlySuccess
	)

TEST() [70/281]

cuttlefish::TEST	(	FetchConfigParserTests	,
		KernelBuildOnlySuccess
	)

TEST() [71/281]

cuttlefish::TEST	(	FetchConfigParserTests	,
		NoBuildStringsProducesNoFlagsSuccess
	)

TEST() [72/281]

cuttlefish::TEST	(	FetchCvdParserTests	,
		CreatesCasDownloaderFlags
	)

TEST() [73/281]

cuttlefish::TEST	(	FilesTest	,
		PathWithCustomEnv
	)

TEST() [74/281]

cuttlefish::TEST	(	FilesTest	,
		PathWithSecondCustomEnv
	)

TEST() [75/281]

cuttlefish::TEST	(	FilesTest	,
		SearchFileNotFoundReturnsError
	)

TEST() [76/281]

cuttlefish::TEST	(	FilesTest	,
		SearchFindsFile
	)

TEST() [77/281]

cuttlefish::TEST	(	FlagParser	,
		BoolFlag
	)

TEST() [78/281]

cuttlefish::TEST	(	FlagParser	,
		BoolFlagXml
	)

TEST() [79/281]

cuttlefish::TEST	(	FlagParser	,
		BoolVectorFlag
	)

TEST() [80/281]

cuttlefish::TEST	(	FlagParser	,
		DuplicateAlias
	)

TEST() [81/281]

cuttlefish::TEST	(	FlagParser	,
		EndOfOptionMark
	)

TEST() [82/281]

cuttlefish::TEST	(	FlagParser	,
		FlagRemoval
	)

TEST() [83/281]

cuttlefish::TEST	(	FlagParser	,
		IntFlag
	)

TEST() [84/281]

cuttlefish::TEST	(	FlagParser	,
		IntFlagXml
	)

TEST() [85/281]

cuttlefish::TEST	(	FlagParser	,
		InvalidIntFlag
	)

TEST() [86/281]

cuttlefish::TEST	(	FlagParser	,
		InvalidStringFlag
	)

TEST() [87/281]

cuttlefish::TEST	(	FlagParser	,
		NormalizedStringFlag
	)

TEST() [88/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalBoolFlag_DefaultOptNotPresent
	)

TEST() [89/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalBoolFlag_DefaultOptPresent_FalseValue
	)

TEST() [90/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalBoolFlag_DefaultOptPresent_FlagOnly
	)

TEST() [91/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalBoolFlag_DefaultOptPresent_TrueValue
	)

TEST() [92/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalBoolFlag_EmptyOptEmptyFlag
	)

TEST() [93/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalBoolFlag_NoFlag
	)

TEST() [94/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalBoolFlag_UnsetOptUnsetValue
	)

TEST() [95/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalInt64Flag_NotPresent
	)

TEST() [96/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalInt64Flag_Present
	)

TEST() [97/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringFlag_DefaultOptEmtpyFlag
	)

TEST() [98/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringFlag_DefaultOptNotPresent
	)

TEST() [99/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringFlag_DefaultOptPresent
	)

TEST() [100/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringFlag_EmptyOptEmtpyFlag
	)

TEST() [101/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringFlag_EmptyOptPresent
	)

TEST() [102/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringFlag_UnsetOptOtherValue
	)

TEST() [103/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringFlag_UnsetOptUnsetValue
	)

TEST() [104/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringVectorFlag_DefaultOptEmptyValue
	)

TEST() [105/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringVectorFlag_DefaultOptNotPresent
	)

TEST() [106/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringVectorFlag_DefaultOptPresent
	)

TEST() [107/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringVectorFlag_EmptyOptEmptyValue
	)

TEST() [108/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringVectorFlag_EmptyOptPresent
	)

TEST() [109/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringVectorFlag_UnsetOptPresent
	)

TEST() [110/281]

cuttlefish::TEST	(	FlagParser	,
		OptionalStringVectorFlag_UnsetOptUnsetValue
	)

TEST() [111/281]

cuttlefish::TEST	(	FlagParser	,
		RepeatedListFlag
	)

TEST() [112/281]

cuttlefish::TEST	(	FlagParser	,
		RepeatedStringFlag
	)

TEST() [113/281]

cuttlefish::TEST	(	FlagParser	,
		StringFlag
	)

TEST() [114/281]

cuttlefish::TEST	(	FlagParser	,
		StringFlagXml
	)

TEST() [115/281]

cuttlefish::TEST	(	FlagParser	,
		StringIntFlag
	)

TEST() [116/281]

cuttlefish::TEST	(	FlagParser	,
		StringVectorFlag
	)

TEST() [117/281]

cuttlefish::TEST	(	FlagParser	,
		UnexpectedArgumentGuard
	)

TEST() [118/281]

cuttlefish::TEST	(	FlagParser	,
		ValueNameHint_Customized
	)

TEST() [119/281]

cuttlefish::TEST	(	FlagParser	,
		ValueNameHint_CustomizedWithAlias
	)

TEST() [120/281]

cuttlefish::TEST	(	FlagParser	,
		ValueNameHint_DefaultDerived
	)

TEST() [121/281]

cuttlefish::TEST	(	FlagParser	,
		ValueNameHint_DefaultDerivedDashed
	)

TEST() [122/281]

cuttlefish::TEST	(	FlagParser	,
		ValueNameHint_DefaultDerivedSnaked
	)

TEST() [123/281]

cuttlefish::TEST	(	FlagParser	,
		VectorFlagValueNameHint_BoolVector
	)

TEST() [124/281]

cuttlefish::TEST	(	FlagParser	,
		VectorFlagValueNameHint_OptionalStringVector
	)

TEST() [125/281]

cuttlefish::TEST	(	FlagParser	,
		VectorFlagValueNameHint_OptionalUnsignedVector
	)

TEST() [126/281]

cuttlefish::TEST	(	FlagParser	,
		VectorFlagValueNameHint_StringVector
	)

TEST() [127/281]

cuttlefish::TEST	(	FlagParser	,
		VectorFlagValueNameHint_UnsignedVector
	)

TEST() [128/281]

cuttlefish::TEST	(	FlagsInheritanceTest	,
		MergeTwoIndependentJson
	)

TEST() [129/281]

cuttlefish::TEST	(	FlagsInheritanceTest	,
		MergeTwoOverlappedJson
	)

TEST() [130/281]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseBasicJsonSingleInstances
	)

TEST() [131/281]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseBasicJsonTwoInstances
	)

TEST() [132/281]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseInvalidJson
	)

TEST() [133/281]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseJsonWithSpellingError
	)

TEST() [134/281]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseMediaMplane
	)

TEST() [135/281]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseMediaSplaneSingleInstance
	)

TEST() [136/281]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseMediaSplaneTwoDevices
	)

TEST() [137/281]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseMediaV4l2Proxy
	)

TEST() [138/281]

cuttlefish::TEST	(	GpxParser	,
		ParseEmptyFile
	)

TEST() [139/281]

cuttlefish::TEST	(	GpxParser	,
		ParseEmptyRteTrkFile
	)

TEST() [140/281]

cuttlefish::TEST	(	GpxParser	,
		ParseEmptyRteTrkString
	)

TEST() [141/281]

cuttlefish::TEST	(	GpxParser	,
		ParseEmptyString
	)

TEST() [142/281]

cuttlefish::TEST	(	GpxParser	,
		ParseFileNotFound
	)

TEST() [143/281]

cuttlefish::TEST	(	GpxParser	,
		ParseFileNullAttributeFile
	)

TEST() [144/281]

cuttlefish::TEST	(	GpxParser	,
		ParseFileNullAttributeString
	)

TEST() [145/281]

cuttlefish::TEST	(	GpxParser	,
		ParseLocationMissingLatitudeFile
	)

TEST() [146/281]

cuttlefish::TEST	(	GpxParser	,
		ParseLocationMissingLatitudeString
	)

TEST() [147/281]

cuttlefish::TEST	(	GpxParser	,
		ParseLocationMissingLongitudeFile
	)

TEST() [148/281]

cuttlefish::TEST	(	GpxParser	,
		ParseLocationMissingLongitudeString
	)

TEST() [149/281]

cuttlefish::TEST	(	GpxParser	,
		ParseValidDocumentFile
	)

TEST() [150/281]

cuttlefish::TEST	(	GpxParser	,
		ParseValidDocumentString
	)

TEST() [151/281]

cuttlefish::TEST	(	GpxParser	,
		ParseValidFile
	)

TEST() [152/281]

cuttlefish::TEST	(	GpxParser	,
		ParseValidLocationFile
	)

TEST() [153/281]

cuttlefish::TEST	(	GpxParser	,
		ParseValidLocationString
	)

TEST() [154/281]

cuttlefish::TEST	(	GpxParser	,
		ParseValidString
	)

TEST() [155/281]

cuttlefish::TEST	(	HostToolManager	,
		KnownBins
	)

TEST() [156/281]

cuttlefish::TEST	(	HostToolTarget	,
		KnownFlags
	)

TEST() [157/281]

cuttlefish::TEST	(	InMemoryIoTest	,
		WriteAtReadAt
	)

TEST() [158/281]

cuttlefish::TEST	(	InMemoryIoTest	,
		WriteSeek
	)

TEST() [159/281]

cuttlefish::TEST	(	InMemoryIoTest	,
		WriteSeekRead
	)

TEST() [160/281]

cuttlefish::TEST	(	InMemoryIoTest	,
		WriteWriteReadAt
	)

TEST() [161/281]

cuttlefish::TEST	(	KernelTest	,
		ParseKernelLineInvalid
	)

TEST() [162/281]

cuttlefish::TEST	(	KernelTest	,
		ParseKernelLineNoColon
	)

TEST() [163/281]

cuttlefish::TEST	(	KernelTest	,
		ParseKernelLineParens
	)

TEST() [164/281]

cuttlefish::TEST	(	KernelTest	,
		ParseKernelLineValid
	)

TEST() [165/281]

cuttlefish::TEST	(	KmlParser	,
		ParseBadCoordinatesFile
	)

TEST() [166/281]

cuttlefish::TEST	(	KmlParser	,
		ParseBadCoordinatesString
	)

TEST() [167/281]

cuttlefish::TEST	(	KmlParser	,
		ParseEmptyKmlFile
	)

TEST() [168/281]

cuttlefish::TEST	(	KmlParser	,
		ParseEmptyKmlString
	)

TEST() [169/281]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationMissingRequiredFieldsFile
	)

TEST() [170/281]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationMissingRequiredFieldsString
	)

TEST() [171/281]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNameOnlyFirstFile
	)

TEST() [172/281]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNameOnlyFirstString
	)

TEST() [173/281]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNormalFile
	)

TEST() [174/281]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNormalMissingOptionalFieldsFile
	)

TEST() [175/281]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNormalMissingOptionalFieldsString
	)

TEST() [176/281]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNormalString
	)

TEST() [177/281]

cuttlefish::TEST	(	KmlParser	,
		ParseMultipleCoordinatesFile
	)

TEST() [178/281]

cuttlefish::TEST	(	KmlParser	,
		ParseMultipleCoordinatesString
	)

TEST() [179/281]

cuttlefish::TEST	(	KmlParser	,
		ParseMultipleLocationsFile
	)

TEST() [180/281]

cuttlefish::TEST	(	KmlParser	,
		ParseMultipleLocationsString
	)

TEST() [181/281]

cuttlefish::TEST	(	KmlParser	,
		ParseNonexistentFile
	)

TEST() [182/281]

cuttlefish::TEST	(	KmlParser	,
		ParseOneCoordinateFile
	)

TEST() [183/281]

cuttlefish::TEST	(	KmlParser	,
		ParseOneCoordinateString
	)

TEST() [184/281]

cuttlefish::TEST	(	KmlParser	,
		ParsePlacemarkNullNameNoCrashFile
	)

TEST() [185/281]

cuttlefish::TEST	(	KmlParser	,
		ParsePlacemarkNullNameNoCrashString
	)

TEST() [186/281]

cuttlefish::TEST	(	KmlParser	,
		ParseValidComplexFile
	)

TEST() [187/281]

cuttlefish::TEST	(	KmlParser	,
		ParseValidComplexString
	)

TEST() [188/281]

cuttlefish::TEST	(	KmlParser	,
		ParseValidKmlFile
	)

TEST() [189/281]

cuttlefish::TEST	(	KmlParser	,
		ParseValidKmlString
	)

TEST() [190/281]

cuttlefish::TEST	(	KmlParser	,
		TraverseDocNoPlacemarksFile
	)

TEST() [191/281]

cuttlefish::TEST	(	KmlParser	,
		TraverseDocNoPlacemarksString
	)

TEST() [192/281]

cuttlefish::TEST	(	KmlParser	,
		TraverseEmptyDocFile
	)

TEST() [193/281]

cuttlefish::TEST	(	KmlParser	,
		TraverseEmptyDocString
	)

TEST() [194/281]

cuttlefish::TEST	(	KmlParser	,
		TraverseNestedDocFile
	)

TEST() [195/281]

cuttlefish::TEST	(	KmlParser	,
		TraverseNestedDocString
	)

TEST() [196/281]

cuttlefish::TEST	(	LauncherTest	,
		ParseLauncherLineInvalid
	)

TEST() [197/281]

cuttlefish::TEST	(	LauncherTest	,
		ParseLauncherLineValid
	)

TEST() [198/281]

cuttlefish::TEST	(	LogcatTest	,
		ParseLogcatLineInvalid
	)

TEST() [199/281]

cuttlefish::TEST	(	LogcatTest	,
		ParseLogcatLineValid
	)

TEST() [200/281]

cuttlefish::TEST	(	LogTeeTest	,
		ParseLogTeeLineInvalid
	)

TEST() [201/281]

cuttlefish::TEST	(	LogTeeTest	,
		ParseLogTeeLineValid
	)

TEST() [202/281]

cuttlefish::TEST	(	ParseBuildStringTests	,
		DeviceBuildStringMultipleSlashesFail
	)

TEST() [203/281]

cuttlefish::TEST	(	ParseBuildStringTests	,
		DeviceBuildStringNoTargetSuccess
	)

TEST() [204/281]

cuttlefish::TEST	(	ParseBuildStringTests	,
		DeviceBuildStringSuccess
	)

TEST() [205/281]

cuttlefish::TEST	(	ParseBuildStringTests	,
		DirectoryBuildStringMultiplePathSuccess
	)

TEST() [206/281]

cuttlefish::TEST	(	ParseBuildStringTests	,
		DirectoryBuildStringSinglePathSuccess
	)

TEST() [207/281]

cuttlefish::TEST	(	ParseBuildStringTests	,
		EmptyStringFail
	)

TEST() [208/281]

cuttlefish::TEST	(	ParseBuildStringTests	,
		FilepathBracketsButNoValueFail
	)

TEST() [209/281]

cuttlefish::TEST	(	ParseBuildStringTests	,
		FilepathExistsMissingBracketFail
	)

TEST() [210/281]

cuttlefish::TEST	(	ParseBuildStringTests	,
		FilepathExistsSuccess
	)

TEST() [211/281]

cuttlefish::TEST	(	ParseBuildStringTests	,
		FilepathOnlyFail
	)

TEST() [212/281]

cuttlefish::TEST	(	Pretty	,
		OuterInnerStruct
	)

TEST() [213/281]

cuttlefish::TEST	(	PrettyContainer	,
		Empty
	)

TEST() [214/281]

cuttlefish::TEST	(	PrettyContainer	,
		MembersWithNewlines
	)

TEST() [215/281]

cuttlefish::TEST	(	PrettyContainer	,
		NestedMember
	)

TEST() [216/281]

cuttlefish::TEST	(	PrettyContainer	,
		OneMember
	)

TEST() [217/281]

cuttlefish::TEST	(	PrettyContainer	,
		StringMember
	)

TEST() [218/281]

cuttlefish::TEST	(	PrettyContainer	,
		TwoMembers
	)

TEST() [219/281]

cuttlefish::TEST	(	PrettyJson	,
		Structured
	)

TEST() [220/281]

cuttlefish::TEST	(	PrettyStruct	,
		Empty
	)

TEST() [221/281]

cuttlefish::TEST	(	PrettyStruct	,
		NestedMembers
	)

TEST() [222/281]

cuttlefish::TEST	(	PrettyStruct	,
		OneMember
	)

TEST() [223/281]

cuttlefish::TEST	(	PrettyStruct	,
		StringMember
	)

TEST() [224/281]

cuttlefish::TEST	(	PrettyStruct	,
		TwoMembers
	)

TEST() [225/281]

cuttlefish::TEST	(	ProcFilePid	,
		CurrentPidCollected
	)

TEST() [226/281]

cuttlefish::TEST	(	ProcFileUid	,
		SelfUidTest
	)

TEST() [227/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectBoolBadNoMessage
	)

TEST() [228/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectBoolBadWithMessage
	)

TEST() [229/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectBoolGoodNoMessage
	)

TEST() [230/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectBoolGoodWithMessage
	)

TEST() [231/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectEqBadNoMessage
	)

TEST() [232/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectEqBadWithMessage
	)

TEST() [233/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectEqGoodNoMessage
	)

TEST() [234/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectEqGoodWithMessage
	)

TEST() [235/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectWithResultBadNoMessage
	)

TEST() [236/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectWithResultBadWithMessage
	)

TEST() [237/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectWithResultGoodNoMessage
	)

TEST() [238/281]

cuttlefish::TEST	(	ResultTest	,
		ExpectWithResultGoodWithMessage
	)

TEST() [239/281]

cuttlefish::TEST	(	SemVer	,
		ParseBasic
	)

TEST() [240/281]

cuttlefish::TEST	(	SemVer	,
		ParseInvalid
	)

TEST() [241/281]

cuttlefish::TEST	(	SemVer	,
		ParseWithPrereleaseAndMetadata
	)

TEST() [242/281]

cuttlefish::TEST	(	SendFD	,
		Basic
	)

TEST() [243/281]

cuttlefish::TEST	(	SingleBuildStringGflagsCompatFlagTests	,
		EmptyInputEmptyResultSuccess
	)

TEST() [244/281]

cuttlefish::TEST	(	SingleBuildStringGflagsCompatFlagTests	,
		HasValueSuccess
	)

TEST() [245/281]

cuttlefish::TEST	(	TpmEncryptedSerializable	,
		BinaryData
	)

TEST() [246/281]

cuttlefish::TEST	(	TruncateColoredStringTest	,
		AnsiNoTruncate
	)

TEST() [247/281]

cuttlefish::TEST	(	TruncateColoredStringTest	,
		AnsiTruncate
	)

TEST() [248/281]

cuttlefish::TEST	(	TruncateColoredStringTest	,
		AnsiTruncateNoResetInInput
	)

TEST() [249/281]

cuttlefish::TEST	(	TruncateColoredStringTest	,
		NoAnsiNoTruncate
	)

TEST() [250/281]

cuttlefish::TEST	(	TruncateColoredStringTest	,
		NoAnsiTruncate
	)

TEST() [251/281]

cuttlefish::TEST	(	UnixMessageSocket	,
		AutoCredentials
	)

TEST() [252/281]

cuttlefish::TEST	(	UnixMessageSocket	,
		BadCredentialsBlocked
	)

TEST() [253/281]

cuttlefish::TEST	(	UnixMessageSocket	,
		SendCredentials
	)

TEST() [254/281]

cuttlefish::TEST	(	UnixMessageSocket	,
		SendFileDescriptor
	)

TEST() [255/281]

cuttlefish::TEST	(	UnixMessageSocket	,
		SendPlainMessage
	)

TEST() [256/281]

cuttlefish::TEST	(	UnixMessageSocket	,
		SendTwoFileDescriptors
	)

TEST() [257/281]

cuttlefish::TEST	(	UnixSocketMessage	,
		ExtractFileDescriptors
	)

TEST() [258/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseOneInstanceSetupWizardInvalidValue
	)

TEST() [259/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesCpuFlagFullJson
	)

TEST() [260/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesCpuFlagPartialJson
	)

TEST() [261/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesCustomActionsFlagEmptyJson
	)

TEST() [262/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesCustomActionsFlagPartialJson
	)

TEST() [263/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesMemoryFlagFullJson
	)

TEST() [264/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesMemoryFlagPartialJson
	)

TEST() [265/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesQemu
	)

TEST() [266/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSandboxFlagFullJson
	)

TEST() [267/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSandboxFlagPartialJson
	)

TEST() [268/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSdCardFlagFullJson
	)

TEST() [269/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSdCardFlagPartialJson
	)

TEST() [270/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSetupWizardFlagFullJson
	)

TEST() [271/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSetupWizardFlagPartialJson
	)

TEST() [272/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSimpleMediaDeviceFlagFullJson
	)

TEST() [273/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSimpleMediaDeviceFlagPartialJson
	)

TEST() [274/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesUuidFlagFullJson
	)

TEST() [275/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesUuidFlagPartialJson
	)

TEST() [276/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesV4l2ProxyFlagFullJson
	)

TEST() [277/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesV4l2ProxyFlagPartialJson
	)

TEST() [278/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesVhostUserVsockFlagFullJson
	)

TEST() [279/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesVhostUserVsockFlagPartialJson
	)

TEST() [280/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesVmManagerFlagDefault
	)

TEST() [281/281]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesVmManagerFlagEmptyJson
	)

TEST_F() [1/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		CacheEnabledIfCacheDirSet
	)

TEST_F() [2/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		CacheMaxSize_DefaultWhenAbsent
	)

TEST_F() [3/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		CacheMaxSize_OverriddenWhenTooSmall
	)

TEST_F() [4/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		DisablesCacheIfCacheDirNotSet
	)

TEST_F() [5/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		DownloadsCompressedIfNotPreferUncompressed
	)

TEST_F() [6/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		DownloadsCompressedIfPreferUncompressedButUnavailable
	)

TEST_F() [7/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		DownloadsDigestsOnlyIfNeeded
	)

TEST_F() [8/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		DownloadsUncompressedIfPreferUncompressed
	)

TEST_F() [9/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		FailsIfArtifactNotInDigestsFile
	)

TEST_F() [10/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		FailsIfDigestsFileDoesNotExist
	)

TEST_F() [11/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		FailsToCreateWithInvalidCasDownloaderPath
	)

TEST_F() [12/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		FailsToCreateWithInvalidConfigPath
	)

TEST_F() [13/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		HandlesFalseBoolFlag
	)

TEST_F() [14/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		HandlesInvocationIdFlag
	)

TEST_F() [15/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		HandlesUnexpectedHelpOutput
	)

TEST_F() [16/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		IgnoresUnsupportedFlags
	)

TEST_F() [17/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		PassesCasOptionsFromCommandLine
	)

TEST_F() [18/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		PassesOptionalStatsFilepathWhenSet
	)

TEST_F() [19/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		RecognizesValidFlags
	)

TEST_F() [20/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		UsesAdcIfServiceAccountUnavailable
	)

TEST_F() [21/42]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		UsesServiceAccountIfAvailable
	)

TEST_F() [22/42]

cuttlefish::TEST_F	(	CasFlagsTests	,
		DefaultValuesAreSet
	)

TEST_F() [23/42]

cuttlefish::TEST_F	(	CasFlagsTests	,
		FlagsMethodReturnsVector
	)

TEST_F() [24/42]

cuttlefish::TEST_F	(	CasFlagsTests	,
		FlagValueCanBeModified
	)

TEST_F() [25/42]

cuttlefish::TEST_F	(	CasFlagsTests	,
		FlagValueComparisons
	)

TEST_F() [26/42]

cuttlefish::TEST_F	(	CasFlagsTests	,
		FlagValueConversion
	)

TEST_F() [27/42]

cuttlefish::TEST_F	(	CasFlagsTests	,
		FlagValueInitializesWithDefault
	)

TEST_F() [28/42]

cuttlefish::TEST_F	(	CasFlagsTests	,
		FlagValuePointerLike
	)

TEST_F() [29/42]

cuttlefish::TEST_F	(	CasFlagsTests	,
		MultipleInstancesIndependent
	)

TEST_F() [30/42]

cuttlefish::TEST_F	(	CasFlagsTests	,
		PriorityLogicCliBlocksConfig
	)

TEST_F() [31/42]

cuttlefish::TEST_F	(	CasFlagsTests	,
		PriorityLogicCliOverridesDefaults
	)

TEST_F() [32/42]

cuttlefish::TEST_F	(	CasFlagsTests	,
		PriorityLogicConfigAppliesWhenNotCli
	)

TEST_F() [33/42]

cuttlefish::TEST_F	(	CvdFlagCollectionTest	,
		AllGivenFlagsListed
	)

TEST_F() [34/42]

cuttlefish::TEST_F	(	CvdFlagCollectionTest	,
		Init
	)

TEST_F() [35/42]

cuttlefish::TEST_F	(	CvdFlagCollectionTest	,
		Leftover
	)

TEST_F() [36/42]

cuttlefish::TEST_F	(	FetchCvdTests	,
		CasDownloaderInvokedIfDownloaderPathSetInCasConfig
	)

TEST_F() [37/42]

cuttlefish::TEST_F	(	FetchCvdTests	,
		CasDownloaderInvokedIfDownloaderPathSetOnCommandLine
	)

TEST_F() [38/42]

cuttlefish::TEST_F	(	FetchCvdTests	,
		CasDownloaderNotCalledIfNoFlags
	)

TEST_F() [39/42]

cuttlefish::TEST_F	(	FilesTests	,
		LinkOrCopyRecursively
	)

TEST_F() [40/42]

cuttlefish::TEST_F	(	FilesTests	,
		LinkOrCopyRecursivelyFailsIfSourceIsNotADirectory
	)

TEST_F() [41/42]

cuttlefish::TEST_F	(	FilesTests	,
		MoveDirectoryContents
	)

TEST_F() [42/42]

cuttlefish::TEST_F	(	FilesTests	,
		MoveDirectoryContentsFailsIfSourceIsNotADirectory
	)

TEST_P()

cuttlefish::TEST_P	(	FrontlineParserTestFixture	,
		FrontlineParserTest
	)

TestComponent()

fruit::Component< TestData > cuttlefish::TestComponent

(

)

TestKeyRsa2048()

std::string cuttlefish::TestKeyRsa2048

(

)

TestKeyRsa4096()

std::string cuttlefish::TestKeyRsa4096

(

)

TestPubKeyRsa2048()

std::string cuttlefish::TestPubKeyRsa2048

(

)

TestPubKeyRsa4096()

std::string cuttlefish::TestPubKeyRsa4096

(

)

TestTapDevices()

static Result< void > cuttlefish::TestTapDevices ( const CuttlefishConfig::InstanceSpecific &  instance )

static

Ti50EmulatorComponent()

fruit::Component< fruit::Required< const CuttlefishConfig, LogTeeCreator, const CuttlefishConfig::InstanceSpecific > > cuttlefish::Ti50EmulatorComponent

(

)

ToEventLabel()

std::string cuttlefish::ToEventLabel

(

const FetchMetrics &

fetch_metrics

)

ToHexString()

std::string cuttlefish::ToHexString

(

const std::vector< uint8_t > &

binary

)

TombstoneReceiver()

Result< MonitorCommand > cuttlefish::TombstoneReceiver

(

const CuttlefishConfig::InstanceSpecific &

instance

)

TombstoneReceiverBinary()

std::string cuttlefish::TombstoneReceiverBinary

(

)

TombstoneReceiverMain()

int cuttlefish::TombstoneReceiverMain	(	int	argc,
		char **	argv
	)

ToSeverity()

Result< LogSeverity > cuttlefish::ToSeverity

(

std::string_view

value

)

ToString() [1/4]

std::string cuttlefish::ToString

(

GuestHwuiRenderer

renderer

)

ToString() [2/4]

std::string cuttlefish::ToString

(

GuestRendererPreload

preload

)

ToString() [3/4]

std::string cuttlefish::ToString

(

SecureHal

hal_in

)

ToString() [4/4]

std::string cuttlefish::ToString

(

VmmMode

mode

)

TouchpadsConfigsComponent()

fruit::Component< TouchpadsConfigs > cuttlefish::TouchpadsConfigsComponent

(

)

TouchpadsConfigsFlagComponent()

fruit::Component< fruit::Required< TouchpadsConfigs, ConfigFlag >, TouchpadsConfigsFlag > cuttlefish::TouchpadsConfigsFlagComponent

(

)

TpmCommandName()

std::string cuttlefish::TpmCommandName

(

uint32_t

command_num

)

TpmDecrypt()

bool cuttlefish::TpmDecrypt	(	ESYS_CONTEXT *	esys,
		ESYS_TR	key_handle,
		TpmAuth	auth,
		const TPM2B_IV &	iv,
		uint8_t *	data_in,
		uint8_t *	data_out,
		size_t	data_size
	)

Decrypt data_in to data_out, which are both buffers of size data_size.

There are no integrity guarantees on this data: if the encrypted data is corrupted, decrypting it could either fail or produce corrupted output.

TpmEncrypt()

bool cuttlefish::TpmEncrypt	(	ESYS_CONTEXT *	esys,
		ESYS_TR	key_handle,
		TpmAuth	auth,
		const TPM2B_IV &	iv,
		uint8_t *	data_in,
		uint8_t *	data_out,
		size_t	data_size
	)

Encrypt data_in to data_out, which are both buffers of size data_size.

There are no integrity guarantees on this data: if the encrypted data is corrupted, decrypting it could either fail or produce corrupted output.

iv should be generated randomly, and can be stored unencrypted next to the plaintext.

TpmEncryptDecrypt()

static bool cuttlefish::TpmEncryptDecrypt ( ESYS_CONTEXT *  esys, ESYS_TR  key_handle, TpmAuth  auth, const TPM2B_IV &  iv, uint8_t *  data_in, uint8_t *  data_out, size_t  data_size, bool  decrypt  )

static

TpmHmac()

UniqueEsysPtr< TPM2B_DIGEST > cuttlefish::TpmHmac	(	TpmResourceManager &	resource_manager,
		ESYS_TR	key_handle,
		TpmAuth	auth,
		const uint8_t *	data,
		size_t	data_size
	)

Returns a HMAC signature for data with the key loaded into the TPM at key_handle.

The signature is a byte string that certifies a process that can make TPM API calls has signed off on using another byte string (data) for some purpose, which is implicitly tied to the signing key. In this case, the secure_env process is the only process that should have TPM access. secure_env can then transmit some data together with a signature over that data, an external system (Android) can hold onto this data and the signature, and then the secure_env process can receive the data back. The signature is used to check that the data has not been tampered with.

TpmHmacWithContext()

UniqueEsysPtr< TPM2B_DIGEST > cuttlefish::TpmHmacWithContext	(	TpmResourceManager &	resource_manager,
		const std::string &	context,
		const uint8_t *	data,
		size_t	data_size
	)

Returns a HMAC signature for data with a key created in the TPM with context / unique-data context.

TransmitMetrics() [1/2]

Result< void > cuttlefish::TransmitMetrics	(	const std::string &	transmitter_binary,
		const CuttlefishLogEvent &	cf_log_event
	)

TransmitMetrics() [2/2]

Result< void > cuttlefish::TransmitMetrics	(	const std::string &	transmitter_binary,
		const logs::proto::wireless::android::cuttlefish::CuttlefishLogEvent &	cf_log_event
	)

TransmitMetricsEvent()

Result< void > cuttlefish::TransmitMetricsEvent	(	const wireless_android_play_playlog::LogRequest &	log_request,
		ClearcutEnvironment	environment
	)

TransmitterPath()

std::string cuttlefish::TransmitterPath

(

)

TruncateColoredString()

TruncatedString cuttlefish::TruncateColoredString	(	std::string_view	s,
		size_t	max_visible_width
	)

TryLoadCuda()

Result< const CudaFunctions * > cuttlefish::TryLoadCuda

(

)

TryLoadNvenc()

Result< const NV_ENCODE_API_FUNCTION_LIST * > cuttlefish::TryLoadNvenc

(

)

TypeIsSuccess() [1/3]

bool cuttlefish::TypeIsSuccess ( bool  value )

inline

TypeIsSuccess() [2/3]

template<typename T >

bool cuttlefish::TypeIsSuccess

(

Result< T > &

value

)

TypeIsSuccess() [3/3]

template<typename T >

bool cuttlefish::TypeIsSuccess

(

std::optional< T > &

value

)

TypeName()

template<typename T >

constexpr std::string_view cuttlefish::TypeName ( )

inlineconstexpr

UnixMessageSocketPair()

std::pair< UnixMessageSocket, UnixMessageSocket > cuttlefish::UnixMessageSocketPair

(

)

UnpackBootImage()

Result< void > cuttlefish::UnpackBootImage	(	const std::string &	boot_image_path,
		const std::string &	unpack_dir
	)

UnpackBootimgBinary()

std::string cuttlefish::UnpackBootimgBinary

(

)

UnpackRamdisk()

Result< void > cuttlefish::UnpackRamdisk	(	const std::string &	original_ramdisk_path,
		const std::string &	ramdisk_stage_dir
	)

UnpackVendorBootImageIfNotUnpacked()

Result< VendorBootImage > cuttlefish::UnpackVendorBootImageIfNotUnpacked	(	const std::string &	vendor_boot_image_path,
		const std::string &	unpack_dir
	)

UpgradeIntegerTag()

static bool cuttlefish::UpgradeIntegerTag ( keymaster_tag_t  tag, uint32_t  value, AuthorizationSet *  set, bool *  set_changed  )

static

UrlEscape()

std::string cuttlefish::UrlEscape

(

std::string_view

text

)

UseQemuPrebuilt()

bool cuttlefish::UseQemuPrebuilt

(

)

UserPageSize()

static std::vector< std::string > cuttlefish::UserPageSize ( const EnvironmentSpecification &  cfg )

static

UseSdcard()

static bool cuttlefish::UseSdcard ( const Instance &  instance )

static

Uuid()

static std::string cuttlefish::Uuid ( const Instance &  instance )

static

UwbConnector()

Result< std::optional< MonitorCommand > > cuttlefish::UwbConnector	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance
	)

V4l2Proxy()

static std::string cuttlefish::V4l2Proxy ( const Instance &  instance )

static

ValidateBoardBootconfigKeys()

Result< void > cuttlefish::ValidateBoardBootconfigKeys	(	const cuttlefish::DeviceType	type,
		const std::map< std::string, std::string, std::less< void > >	args
	)

ValidateCfConfigs()

Result< cvd::config::EnvironmentSpecification > cuttlefish::ValidateCfConfigs

(

const Json::Value &

root

)

ValidateCvdallocBinary()

Result< void > cuttlefish::ValidateCvdallocBinary

(

std::string_view

path

)

ValidateHostConfiguration()

Result< void > cuttlefish::ValidateHostConfiguration

(

)

ValidateHostKernel()

Result< void > cuttlefish::ValidateHostKernel

(

)

ValidateSecureHals()

Result< void > cuttlefish::ValidateSecureHals

(

const std::set< SecureHal > &

secure_hals

)

ValidateSetupWizardMode()

Result< void > cuttlefish::ValidateSetupWizardMode

(

const std::string &

setupwizard_mode

)

ValidateTapDevices()

Result< void > cuttlefish::ValidateTapDevices

(

const CuttlefishConfig::InstanceSpecific &

instance

)

ValueName()

template<auto T>

constexpr std::string_view cuttlefish::ValueName ( )

inlineconstexpr

VbmetaEnforceMinimumSize()

Result< void > cuttlefish::VbmetaEnforceMinimumSize

(

const CuttlefishConfig::InstanceSpecific &

instance

)

VhalProxyServer()

std::optional< MonitorCommand > cuttlefish::VhalProxyServer

(

const CuttlefishConfig::InstanceSpecific &

instance

)

VhalProxyServerBinary()

std::string cuttlefish::VhalProxyServerBinary

(

)

VhalProxyServerConfig()

std::string cuttlefish::VhalProxyServerConfig

(

)

VhostDeviceVsockComponent()

fruit::Component< fruit::Required< const CuttlefishConfig, LogTeeCreator, const CuttlefishConfig::InstanceSpecific > > cuttlefish::VhostDeviceVsockComponent

(

)

VhostInputDevicesComponent()

fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific >, InputPathsProvider, LogTeeCreator > cuttlefish::VhostInputDevicesComponent

(

)

VhostUserInputBinary()

std::string cuttlefish::VhostUserInputBinary

(

)

VhostUserMediaDevicesComponent()

fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific, LogTeeCreator > > cuttlefish::VhostUserMediaDevicesComponent

(

)

VhostUserMediaEmulatedCameraMPlaneBinary()

std::string cuttlefish::VhostUserMediaEmulatedCameraMPlaneBinary

(

)

VhostUserMediaEmulatedCameraSPlaneBinary()

std::string cuttlefish::VhostUserMediaEmulatedCameraSPlaneBinary

(

)

VhostUserMediaV4l2StreamProxyBinary()

std::string cuttlefish::VhostUserMediaV4l2StreamProxyBinary

(

)

VhostUserVsock()

static std::string cuttlefish::VhostUserVsock ( const Instance &  instance )

static

VmManager()

static std::string cuttlefish::VmManager ( const Instance &  instance )

static

VmManagerIsCrosvm() [1/3]

bool cuttlefish::VmManagerIsCrosvm

(

const CuttlefishConfig &

config

)

VmManagerIsCrosvm() [2/3]

bool cuttlefish::VmManagerIsCrosvm

(

const VmManagerFlag &

vmm

)

VmManagerIsCrosvm() [3/3]

bool cuttlefish::VmManagerIsCrosvm

(

VmmMode

mode

)

VmManagerIsGem5() [1/3]

bool cuttlefish::VmManagerIsGem5

(

const CuttlefishConfig &

config

)

VmManagerIsGem5() [2/3]

bool cuttlefish::VmManagerIsGem5

(

const VmManagerFlag &

vmm

)

VmManagerIsGem5() [3/3]

bool cuttlefish::VmManagerIsGem5

(

VmmMode

mode

)

VmManagerIsQemu() [1/3]

bool cuttlefish::VmManagerIsQemu

(

const CuttlefishConfig &

config

)

VmManagerIsQemu() [2/3]

bool cuttlefish::VmManagerIsQemu

(

const VmManagerFlag &

vmm

)

VmManagerIsQemu() [3/3]

bool cuttlefish::VmManagerIsQemu

(

VmmMode

mode

)

VsockGuestGroup()

static std::string cuttlefish::VsockGuestGroup ( const Instance &  instance )

static

WaitForRead()

Result< void > cuttlefish::WaitForRead	(	SharedFD	monitor_socket,
		const int	timeout_seconds
	)

WaitForUnixSocket()

Result< void > cuttlefish::WaitForUnixSocket	(	const std::string &	path,
		int	timeoutSec
	)

WaitForUnixSocketListeningWithoutConnect()

Result< void > cuttlefish::WaitForUnixSocketListeningWithoutConnect	(	const std::string &	path,
		int	timeoutSec
	)

WalkDirectory()

Result< void > cuttlefish::WalkDirectory	(	const std::string &	dir,
		const WalkDirectoryCallback &	callback
	)

WebRtcBinary()

std::string cuttlefish::WebRtcBinary

(

)

WebRtcComponent()

fruit::Component< CustomActionConfigProvider > cuttlefish::WebRtcComponent

(

)

WebRtcControllerComponent()

fruit::Component< WebRtcController > cuttlefish::WebRtcControllerComponent

(

)

WebRtcSigServerBinary()

std::string cuttlefish::WebRtcSigServerBinary

(

)

WebRtcSigServerProxyBinary()

std::string cuttlefish::WebRtcSigServerProxyBinary

(

)

WithCrc16A()

Result< std::vector< uint8_t > > cuttlefish::WithCrc16A

(

const std::vector< uint8_t > &

data

)

WithCrc16B()

Result< std::vector< uint8_t > > cuttlefish::WithCrc16B

(

const std::vector< uint8_t > &

data

)

WithFallbackTarget()

BuildString cuttlefish::WithFallbackTarget	(	BuildString	build_string,
		std::string	fallback
	)

WmediumdBinary()

std::string cuttlefish::WmediumdBinary

(

)

WmediumdGenConfigBinary()

std::string cuttlefish::WmediumdGenConfigBinary

(

)

WmediumdServerComponent()

fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::EnvironmentSpecific, const CuttlefishConfig::InstanceSpecific, LogTeeCreator, GrpcSocketCreator > > cuttlefish::WmediumdServerComponent

(

)

WriteAll() [1/3]

ssize_t cuttlefish::WriteAll	(	SharedFD	fd,
		const char *	buf,
		size_t	size
	)

Writes to fd until size bytes are written from buf.

On a successful write, returns size.

If a write error is encountered, returns -1. Some data may have already been written to fd at that point.

If size is 0, WriteAll returns 0 with no error set unless the fd is a regular file. If fd is a regular file, write(fd, buf, 0) is effectively called. It may detect errors; if detected, errno is set and -1 is returned. If not detected, 0 is returned with errno unchanged.

WriteAll() [2/3]

ssize_t cuttlefish::WriteAll	(	SharedFD	fd,
		const std::vector< char > &	buf
	)

Writes to fd until writing all bytes in buf.

On a successful write, returns buf.size().

If a write error is encountered, returns -1. Some data may have already been written to fd at that point.

If the size of buf is 0, WriteAll returns 0 with no error set unless the fd is a regular file. If fd is a regular file, write(fd, buf, 0) is effectively called. It may detect errors; if detected, errno is set and -1 is returned. If not detected, 0 is returned with errno unchanged.

WriteAll() [3/3]

ssize_t cuttlefish::WriteAll	(	SharedFD	fd,
		std::string_view	buf
	)

Writes to fd until writing all bytes in buf.

On a successful write, returns buf.size().

If a write error is encountered, returns -1. Some data may have already been written to fd at that point.

If the size of buf is 0, WriteAll returns 0 with no error set unless the fd is a regular file. If fd is a regular file, write(fd, buf, 0) is effectively called. It may detect errors; if detected, errno is set and -1 is returned. If not detected, 0 is returned with errno unchanged.

WriteAllBinary()

template<typename T >

ssize_t cuttlefish::WriteAllBinary	(	SharedFD	fd,
		const T *	binary_data
	)

Writes to fd until sizeof(T) bytes are written from binary_data.

On a successful write, returns sizeof(T).

If a write error is encountered, returns -1. Some data may have already been written to fd at that point.

If ever sizeof(T) is 0, WriteAll returns 0 with no error set unless the fd is a regular file. If fd is a regular file, write(fd, buf, 0) is effectively called. It may detect errors; if detected, errno is set and -1 is returned. If not detected, 0 is returned with errno unchanged.

WriteCvdDataFile()

Result< void > cuttlefish::WriteCvdDataFile	(	std::string_view	path,
		std::string	contents
	)

WriteExact() [1/5]

Result< void > cuttlefish::WriteExact	(	Writer &	writer,
		const char *	buf
	)

WriteExact() [2/5]

Result< void > cuttlefish::WriteExact	(	Writer &	writer,
		const char *	buf,
		size_t	size
	)

WriteExact() [3/5]

Result< void > cuttlefish::WriteExact	(	Writer &	writer,
		const std::string &	str
	)

WriteExact() [4/5]

Result< void > cuttlefish::WriteExact	(	Writer &	writer,
		const std::string_view	str
	)

WriteExact() [5/5]

Result< void > cuttlefish::WriteExact	(	Writer &	writer,
		const std::vector< char > &	vec
	)

WriteExactBinary()

template<typename T >

Result< void > cuttlefish::WriteExactBinary	(	Writer &	writer,
		const T &	data
	)

WriteFailureRecordImpl()

static Result< void > cuttlefish::WriteFailureRecordImpl ( secure_env::Storage &  storage, uint32_t  uid, gatekeeper::failure_record_t *  record  )

static

WriteGflagsCompatXml() [1/2]

void cuttlefish::WriteGflagsCompatXml	(	const Flag &	flag,
		std::ostream &	out
	)

WriteGflagsCompatXml() [2/2]

void cuttlefish::WriteGflagsCompatXml	(	const std::vector< Flag > &	flags,
		std::ostream &	out
	)

WriteKeyEqualsValue() [1/2]

Result< void > cuttlefish::WriteKeyEqualsValue	(	const std::map< std::string, std::string > &	key_equals_value,
		const std::string &	path
	)

WriteKeyEqualsValue() [2/2]

Result< void > cuttlefish::WriteKeyEqualsValue	(	const std::map< std::string, std::string, std::less< void > > &	key_equals_value,
		const std::string &	path
	)

WriteMetricsEvent() [1/2]

Result< void > cuttlefish::WriteMetricsEvent	(	std::string_view	event_type_label,
		std::string_view	metrics_directory,
		const CuttlefishLogEvent &	cf_log_event
	)

WriteMetricsEvent() [2/2]

Result< void > cuttlefish::WriteMetricsEvent	(	std::string_view	event_type_label,
		std::string_view	metrics_directory,
		const logs::proto::wireless::android::cuttlefish::CuttlefishLogEvent &	cf_log_event
	)

WriteNewFile()

Result< void > cuttlefish::WriteNewFile	(	const std::string &	filepath,
		std::string_view	content,
		mode_t	mode
	)

WriteProtectedJsonToFile()

bool cuttlefish::WriteProtectedJsonToFile	(	TpmResourceManager &	resource_manager,
		const std::string &	filename,
		Json::Value	json
	)

XmlEscape()

static std::string cuttlefish::XmlEscape ( const std::string &  s )

static

ZipErrorString() [1/3]

std::string cuttlefish::ZipErrorString

(

zip_error_t *

error

)

ZipErrorString() [2/3]

std::string cuttlefish::ZipErrorString

(

zip_source_t *

source

)

ZipErrorString() [3/3]

std::string cuttlefish::ZipErrorString

(

zip_t *

source

)

ZipOpenRead()

Result< ReadableZip > cuttlefish::ZipOpenRead

(

const std::string &

fs_path

)

ZipOpenReadWrite()

Result< WritableZip > cuttlefish::ZipOpenReadWrite

(

const std::string &

fs_path

)

ZipSourceAsReaderSeeker()

Result< std::unique_ptr< ReaderSeeker > > cuttlefish::ZipSourceAsReaderSeeker

(

SeekableZipSource

inner

)

ZipSourceFromUrl()

Result< SeekableZipSource > cuttlefish::ZipSourceFromUrl	(	HttpClient &	http_client,
		const std::string &	url,
		std::vector< std::string >	headers
	)

Variable Documentation

BLOCK_SIZE

constexpr uint32_t cuttlefish::BLOCK_SIZE = 16

staticconstexpr

CHUNK_RECV_MAX_LEN

constexpr size_t cuttlefish::CHUNK_RECV_MAX_LEN = 1024

staticconstexpr

CommandAlwaysFalse

template<class... >

constexpr std::false_type cuttlefish::CommandAlwaysFalse {}

constexpr

DF_ADF

const std::string cuttlefish::DF_ADF = "7FFF"

static

DF_CDMA

const std::string cuttlefish::DF_CDMA = "7F25"

static

DF_GRAPHICS

const std::string cuttlefish::DF_GRAPHICS = "5F50"

static

DF_GSM

const std::string cuttlefish::DF_GSM = "7F20"

static

DF_PHONEBOOK

const std::string cuttlefish::DF_PHONEBOOK = "5F3A"

static

DF_TELECOM

const std::string cuttlefish::DF_TELECOM = "7F10"

static

DISK_SIZE_SHIFT

constexpr int cuttlefish::DISK_SIZE_SHIFT = 16

constexpr

GPT_NUM_PARTITIONS

constexpr int cuttlefish::GPT_NUM_PARTITIONS = 128

constexpr

gSimStatusResponse

const std::map<SimService::SimStatus, std::string> cuttlefish::gSimStatusResponse

Initial value:

= {
    {SimService::SIM_STATUS_ABSENT,     ModemService::kCmeErrorSimNotInserted},
    {SimService::SIM_STATUS_NOT_READY,  ModemService::kCmeErrorSimBusy},
    {SimService::SIM_STATUS_READY,      "+CPIN: READY"},
    {SimService::SIM_STATUS_PIN,        "+CPIN: SIM PIN"},
    {SimService::SIM_STATUS_PUK,        "+CPIN: SIM PUK"},
}

kAdbdStartedMessage

constexpr char cuttlefish::kAdbdStartedMessage[]

inlineconstexpr

Initial value:

=
    "init: starting service 'adbd'..."

kAdbIPAndPort

constexpr char cuttlefish::kAdbIPAndPort[] = "adb_ip_and_port"

staticconstexpr

kAllSafeLevels

constexpr SafeLevel cuttlefish::kAllSafeLevels[]

inlineconstexpr

Initial value:

= {
    SafeLevel::kPlatinum,
    SafeLevel::kSafe2,
    SafeLevel::kSafe1,
    SafeLevel::kSafe0,
    SafeLevel::kSafeLevelUnspecified,
}

kAndroidBuildApiScope

constexpr char cuttlefish::kAndroidBuildApiScope[]

inlineconstexpr

Initial value:

=
    "https://www.googleapis.com/auth/androidbuild.internal"

kAndroidBuildServiceUrl

constexpr char cuttlefish::kAndroidBuildServiceUrl[]

inlineconstexpr

Initial value:

=
    "https://androidbuild-pa.googleapis.com/v4"

kAndroidEfiLoader

constexpr char cuttlefish::kAndroidEfiLoader[] = "android_efi_loader"

staticconstexpr

kAndroidHostOut

constexpr char cuttlefish::kAndroidHostOut[] = "ANDROID_HOST_OUT"

constexpr

kAndroidProductOut

constexpr char cuttlefish::kAndroidProductOut[] = "ANDROID_PRODUCT_OUT"

constexpr

kAndroidSoongHostOut

constexpr char cuttlefish::kAndroidSoongHostOut[] = "ANDROID_SOONG_HOST_OUT"

constexpr

kAnsiBoldBlue

constexpr std::string_view cuttlefish::kAnsiBoldBlue = "\033[1;34m"

inlineconstexpr

kAnsiBoldCyan

constexpr std::string_view cuttlefish::kAnsiBoldCyan = "\033[1;36m"

inlineconstexpr

kAnsiClearScreen

constexpr std::string_view cuttlefish::kAnsiClearScreen = "\033[2J"

inlineconstexpr

kAnsiClearScreenAfterCursor

constexpr std::string_view cuttlefish::kAnsiClearScreenAfterCursor = "\033[J"

inlineconstexpr

kAnsiCsi

constexpr std::string_view cuttlefish::kAnsiCsi = "\033["

inlineconstexpr

kAnsiCursorTopLeft

constexpr std::string_view cuttlefish::kAnsiCursorTopLeft = "\033[;H"

inlineconstexpr

kAnsiCyan

constexpr std::string_view cuttlefish::kAnsiCyan = "\033[0;36m"

inlineconstexpr

kAnsiGreen

constexpr std::string_view cuttlefish::kAnsiGreen = "\033[0;32m"

inlineconstexpr

kAnsiGrey

constexpr std::string_view cuttlefish::kAnsiGrey = "\033[90m"

inlineconstexpr

kAnsiRed

constexpr std::string_view cuttlefish::kAnsiRed = "\033[0;31m"

inlineconstexpr

kAnsiReset

constexpr std::string_view cuttlefish::kAnsiReset = "\033[0m"

inlineconstexpr

kAnsiWhite

constexpr std::string_view cuttlefish::kAnsiWhite = "\033[0;37m"

inlineconstexpr

kAnsiYellow

constexpr std::string_view cuttlefish::kAnsiYellow = "\033[0;33m"

inlineconstexpr

kApBootFlow

constexpr char cuttlefish::kApBootFlow[] = "ap_boot_flow"

staticconstexpr

kApKernelImage

constexpr char cuttlefish::kApKernelImage[] = "ap_kernel_image"

staticconstexpr

kApName

constexpr char cuttlefish::kApName[] = "crosvm_openwrt"

inlineconstexpr

kApRootfsImage

constexpr char cuttlefish::kApRootfsImage[] = "ap_rootfs_image"

staticconstexpr

kApVmManager

constexpr char cuttlefish::kApVmManager[] = "ap_vm_manager"

staticconstexpr

kAreaCode

const std::string cuttlefish::kAreaCode = "2142"

static

kAudioControlServerPort

constexpr char cuttlefish::kAudioControlServerPort[] = "audiocontrol_server_port"

staticconstexpr

kAudioOutputStreamsCount

constexpr char cuttlefish::kAudioOutputStreamsCount[] = "audio_output_streams_count"

staticconstexpr

kAudioSettingsTextProto

constexpr char cuttlefish::kAudioSettingsTextProto[] = "audio_settings_textproto"

staticconstexpr

kAutoInstanceTemplate

constexpr std::string_view cuttlefish::kAutoInstanceTemplate

staticconstexpr

Initial value:

= R""""(
{
    "vm": {
        "memory_mb": 4096
    },
    "graphics":{
        "displays":[
            {
                "width": 1080,
                "height": 600,
                "dpi": 120
            },
            {
                "width": 400,
                "height": 600,
                "dpi": 120
            }
        ]
    }
}
  )""""

kBadCoordinatesText

char cuttlefish::kBadCoordinatesText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<Placemark>"
    "<LineString>"
    "<coordinates>-122.0822035425683, 37.42228990140251, 0 \
                  10.4,39.20\t021.41"
    "</coordinates>"
    "</LineString>"
    "</Placemark>"
    "</kml>"

kBerUnknownValue

constexpr int cuttlefish::kBerUnknownValue = 99

constexpr

kBlankDataImageMb

constexpr char cuttlefish::kBlankDataImageMb[] = "blank_data_image_mb"

staticconstexpr

kBlankSdcardImageMb

constexpr char cuttlefish::kBlankSdcardImageMb[] = "blank_sdcard_image_mb"

staticconstexpr

kBootCompletedMessage

constexpr char cuttlefish::kBootCompletedMessage[] = "VIRTUAL_DEVICE_BOOT_COMPLETED"

inlineconstexpr

kBootconfigSupported

constexpr char cuttlefish::kBootconfigSupported[] = "bootconfig_supported"

staticconstexpr

kBootDestPathAA64

constexpr char cuttlefish::kBootDestPathAA64[] = "/EFI/BOOT/BOOTAA64.EFI"

staticconstexpr

kBootDestPathRiscV64

constexpr char cuttlefish::kBootDestPathRiscV64[] = "/EFI/BOOT/BOOTRISCV64.EFI"

staticconstexpr

kBootDestPathX64

constexpr char cuttlefish::kBootDestPathX64[] = "/EFI/BOOT/BOOTX64.EFI"

staticconstexpr

kBootFailedMessage

constexpr char cuttlefish::kBootFailedMessage[] = "VIRTUAL_DEVICE_BOOT_FAILED"

inlineconstexpr

kBootImagePageSize

constexpr uint32_t cuttlefish::kBootImagePageSize = 4096

inlineconstexpr

kBootloader

constexpr char cuttlefish::kBootloader[] = "bootloader"

staticconstexpr

kBootloaderLoadedMessage

constexpr char cuttlefish::kBootloaderLoadedMessage[] = "U-Boot 20"

inlineconstexpr

kBootPendingMessage

constexpr char cuttlefish::kBootPendingMessage[] = "VIRTUAL_DEVICE_BOOT_PENDING"

inlineconstexpr

kBootSlot

constexpr char cuttlefish::kBootSlot[] = "boot_slot"

staticconstexpr

kBootSrcPathAA64

constexpr char cuttlefish::kBootSrcPathAA64[]

staticconstexpr

Initial value:

=
    "/usr/lib/grub/arm64-efi/monolithic/grubaa64.efi"

kBootSrcPathX64

constexpr char cuttlefish::kBootSrcPathX64[]

staticconstexpr

Initial value:

=
    "/usr/lib/grub/x86_64-efi/monolithic/grubx64.efi"

kBootStartedMessage

constexpr char cuttlefish::kBootStartedMessage[] = "VIRTUAL_DEVICE_BOOT_STARTED"

inlineconstexpr

kBufferSize

constexpr size_t cuttlefish::kBufferSize = 1 << 26

staticconstexpr

kCameraServerPort

constexpr char cuttlefish::kCameraServerPort[] = "camera_server_port"

staticconstexpr

kCasCacheDir

constexpr char cuttlefish::kCasCacheDir[] = "--cas_cache_dir=/tmp/cas_cache"

inlineconstexpr

kCasCacheMaxSize

constexpr char cuttlefish::kCasCacheMaxSize[] = "--cas_cache_max_size=10000000000"

inlineconstexpr

kCasDownloaderPath

constexpr char cuttlefish::kCasDownloaderPath[]

inlineconstexpr

Initial value:

=
    "--cas_downloader_path=/tmp/casdownloader"

kCasimirArgs

constexpr char cuttlefish::kCasimirArgs[] = "casimir_args"

staticconstexpr

kCasimirInstanceNum

constexpr char cuttlefish::kCasimirInstanceNum[] = "casimir_instance_num"

staticconstexpr

kCasimirNciPort

constexpr char cuttlefish::kCasimirNciPort[] = "casimir_nci_port"

staticconstexpr

kCasimirRfPort

constexpr char cuttlefish::kCasimirRfPort[] = "casimir_rf_port"

staticconstexpr

kCellId

const std::string cuttlefish::kCellId = "0000B804"

static

kCfHomeField

constexpr const char cuttlefish::kCfHomeField[] = "HOME"

inlineconstexpr

kChromeOsDisk

constexpr char cuttlefish::kChromeOsDisk[] = "chromeos_disk"

staticconstexpr

kChromeOsKernelPath

constexpr char cuttlefish::kChromeOsKernelPath[] = "chromeos_kernel_path"

staticconstexpr

kChromeOsRootImage

constexpr char cuttlefish::kChromeOsRootImage[] = "chromeos_root_image"

staticconstexpr

kClearcutLocal

constexpr std::string_view cuttlefish::kClearcutLocal = "local"

inlineconstexpr

kClearcutProduction

constexpr std::string_view cuttlefish::kClearcutProduction = "production"

inlineconstexpr

kClearcutStaging

constexpr std::string_view cuttlefish::kClearcutStaging = "staging"

inlineconstexpr

kCloudStorageReadScope

constexpr char cuttlefish::kCloudStorageReadScope[]

inlineconstexpr

Initial value:

=
    "https://www.googleapis.com/auth/devstorage.read_only"

kConsole

constexpr char cuttlefish::kConsole[] = "console"

staticconstexpr

kConsoleSeverityEnvVar

constexpr const char* cuttlefish::kConsoleSeverityEnvVar = "CF_CONSOLE_SEVERITY"

constexpr

kCpus

constexpr char cuttlefish::kCpus[] = "cpus"

staticconstexpr

kCrcSize

constexpr uint32_t cuttlefish::kCrcSize = sizeof(uint32_t)

staticconstexpr

kCrosvmAcpiTable

constexpr char cuttlefish::kCrosvmAcpiTable[] = "crosvm_acpi_table"

staticconstexpr

kCrosvmBinary [1/2]

constexpr char cuttlefish::kCrosvmBinary[] = "crosvm_binary"

staticconstexpr

kCrosvmBinary [2/2]

constexpr char cuttlefish::kCrosvmBinary[] = "crosvm_binary"

staticconstexpr

kCrosvmDeviceTreeOverlay

constexpr char cuttlefish::kCrosvmDeviceTreeOverlay[] = "crosvm_device_tree_overlay"

staticconstexpr

kCrosvmFileBackedMapping

constexpr char cuttlefish::kCrosvmFileBackedMapping[] = "crosvm_file_backed_mapping"

staticconstexpr

kCrosvmSimpleMediaDevice

constexpr char cuttlefish::kCrosvmSimpleMediaDevice[] = "crosvm_simple_media_device"

staticconstexpr

kCrosvmUseBalloon

constexpr char cuttlefish::kCrosvmUseBalloon[] = "crosvm_use_balloon"

staticconstexpr

kCrosvmUsePmem

constexpr char cuttlefish::kCrosvmUsePmem[] = "use_pmem"

staticconstexpr

kCrosvmUseRng

constexpr char cuttlefish::kCrosvmUseRng[] = "crosvm_use_rng"

staticconstexpr

kCrosvmV4l2Proxy

constexpr char cuttlefish::kCrosvmV4l2Proxy[] = "crosvm_v4l2_proxy"

staticconstexpr

kCrosvmVarEmptyDir

constexpr char cuttlefish::kCrosvmVarEmptyDir[] = "/var/empty"

inlineconstexpr

kCustomKeyboardConfig

constexpr char cuttlefish::kCustomKeyboardConfig[] = "custom_keyboard_config"

staticconstexpr

kCustomPartitionPath

constexpr char cuttlefish::kCustomPartitionPath[] = "custom_partition_path"

staticconstexpr

kCuttlefishConfigEnvVarName

constexpr char cuttlefish::kCuttlefishConfigEnvVarName[] = "CUTTLEFISH_CONFIG_FILE"

inlineconstexpr

kCuttlefishInstanceEnvVarName

constexpr char cuttlefish::kCuttlefishInstanceEnvVarName[] = "CUTTLEFISH_INSTANCE"

inlineconstexpr

kCvdAllocateTimeout

constexpr std::chrono::seconds cuttlefish::kCvdAllocateTimeout = std::chrono::seconds(30)

constexpr

kCvdallocEthernetBridgeName

constexpr std::string_view cuttlefish::kCvdallocEthernetBridgeName = "cvd-pi-ebr"

constexpr

kCvdallocEthernetIpPrefix

constexpr char cuttlefish::kCvdallocEthernetIpPrefix[] = "192.168.192"

constexpr

kCvdallocInterfacePrefix

constexpr std::string_view cuttlefish::kCvdallocInterfacePrefix = "cvd-pi"

constexpr

kCvdallocMobileIpPrefix

constexpr char cuttlefish::kCvdallocMobileIpPrefix[] = "192.168.144"

constexpr

kCvdallocWirelessApIpPrefix

constexpr char cuttlefish::kCvdallocWirelessApIpPrefix[] = "192.168.176"

constexpr

kCvdallocWirelessBridgeName

constexpr std::string_view cuttlefish::kCvdallocWirelessBridgeName = "cvd-pi-wbr"

constexpr

kCvdallocWirelessIpPrefix

constexpr char cuttlefish::kCvdallocWirelessIpPrefix[] = "192.168.160"

constexpr

kCvdMarkEnv

constexpr char cuttlefish::kCvdMarkEnv[] = "_STARTED_BY_CVD_SERVER_"

staticconstexpr

kCvdNamePrefix

constexpr char cuttlefish::kCvdNamePrefix[] = "cvd-"

inlineconstexpr

kCvdNetworkGroupName

constexpr char cuttlefish::kCvdNetworkGroupName[] = "cvdnetwork"

inlineconstexpr

kCvdRetainLogFilesNum

constexpr size_t cuttlefish::kCvdRetainLogFilesNum = 30

inlineconstexpr

kCvdTeardownTimeout

constexpr std::chrono::seconds cuttlefish::kCvdTeardownTimeout = std::chrono::seconds(2)

constexpr

kDataImage

constexpr char cuttlefish::kDataImage[] = "data_image"

staticconstexpr

kDataPolicy

constexpr char cuttlefish::kDataPolicy[] = "data_policy"

staticconstexpr

kDbmRange

constexpr auto cuttlefish::kDbmRange = std::make_pair(-120, -4)

constexpr

kDbmUnknownValue

constexpr int cuttlefish::kDbmUnknownValue = -1

constexpr

kDdrMemMb

constexpr char cuttlefish::kDdrMemMb[] = "ddr_mem_mb"

staticconstexpr

kDefaultApiKey

constexpr char cuttlefish::kDefaultApiKey[] = ""

inlineconstexpr

kDefaultBatchReadBlobsTimeout

constexpr int cuttlefish::kDefaultBatchReadBlobsTimeout = 180

inlineconstexpr

kDefaultBatchUpdateBlobsTimeout

constexpr int cuttlefish::kDefaultBatchUpdateBlobsTimeout = 60

inlineconstexpr

kDefaultBuild

constexpr char cuttlefish::kDefaultBuild[]

inlineconstexpr

Initial value:

=
    "--default_build=aosp-android-latest-release/"
    "aosp_cf_x86_64_only_phone-userdebug"

kDefaultBuildString

constexpr char cuttlefish::kDefaultBuildString[] = ""

inlineconstexpr

kDefaultBuildTarget

constexpr char cuttlefish::kDefaultBuildTarget[]

inlineconstexpr

Initial value:

=
    "aosp_cf_x86_64_only_phone-userdebug"

kDefaultCacheSizeGb

constexpr size_t cuttlefish::kDefaultCacheSizeGb = 25

inlineconstexpr

kDefaultCasConcurrency

constexpr int cuttlefish::kDefaultCasConcurrency = 500

inlineconstexpr

kDefaultCasConfigFilePath

constexpr const char cuttlefish::kDefaultCasConfigFilePath[]

inlineconstexpr

Initial value:

=
    "/etc/casdownloader/config.json"

kDefaultCredentialFilepath

constexpr char cuttlefish::kDefaultCredentialFilepath[] = ""

inlineconstexpr

kDefaultCredentialSource

constexpr char cuttlefish::kDefaultCredentialSource[] = ""

inlineconstexpr

kDefaultDownloaderPath

constexpr const char cuttlefish::kDefaultDownloaderPath[] = "/usr/bin/casdownloader"

inlineconstexpr

kDefaultDownloadImgZip

constexpr bool cuttlefish::kDefaultDownloadImgZip = true

inlineconstexpr

kDefaultDownloadTargetFilesZip

constexpr bool cuttlefish::kDefaultDownloadTargetFilesZip = false

inlineconstexpr

kDefaultDynamicSuperImageFragments

constexpr bool cuttlefish::kDefaultDynamicSuperImageFragments = false

inlineconstexpr

kDefaultEmergencyMode

constexpr bool cuttlefish::kDefaultEmergencyMode = false

staticconstexpr

kDefaultEnableCaching

constexpr bool cuttlefish::kDefaultEnableCaching = true

inlineconstexpr

kDefaultGetCapabilitiesTimeout

constexpr int cuttlefish::kDefaultGetCapabilitiesTimeout = 5

inlineconstexpr

kDefaultGetTreeTimeout

constexpr int cuttlefish::kDefaultGetTreeTimeout = 5

inlineconstexpr

kDefaultInstance

constexpr int cuttlefish::kDefaultInstance = 1

inlineconstexpr

kDefaultInterfacePrefix

constexpr std::string_view cuttlefish::kDefaultInterfacePrefix = "cvd"

constexpr

kDefaultKeepDownloadedArchives

constexpr bool cuttlefish::kDefaultKeepDownloadedArchives = false

inlineconstexpr

kDefaultMaxLineWidth

constexpr size_t cuttlefish::kDefaultMaxLineWidth = 80

constexpr

kDefaultMemoryLimit

constexpr int cuttlefish::kDefaultMemoryLimit = 0

inlineconstexpr

kDefaultModemTechnoloy

constexpr int cuttlefish::kDefaultModemTechnoloy = ModemTechnology::M_MODEM_TECH_LTE

staticconstexpr

kDefaultNetworkSelectionMode

constexpr int cuttlefish::kDefaultNetworkSelectionMode = 0

staticconstexpr

kDefaultOPeratorControlSocketPath

constexpr char cuttlefish::kDefaultOPeratorControlSocketPath[]

constexpr

Initial value:

=
    "/run/cuttlefish/operator_control"

kDefaultPinCode

const std::string cuttlefish::kDefaultPinCode = "1234"

static

kDefaultPreferredNetworkMode

constexpr int cuttlefish::kDefaultPreferredNetworkMode

staticconstexpr

Initial value:

=
    ModemTechnology::M_MODEM_TECH_LTE | ModemTechnology::M_MODEM_TECH_WCDMA |
    ModemTechnology::M_MODEM_TECH_GSM

kDefaultProjectID

constexpr char cuttlefish::kDefaultProjectID[] = ""

inlineconstexpr

kDefaultPukCode

const std::string cuttlefish::kDefaultPukCode = "12345678"

static

kDefaultRpcTimeout

constexpr int cuttlefish::kDefaultRpcTimeout = 120

inlineconstexpr

kDefaultServiceAccountFilepath

constexpr char cuttlefish::kDefaultServiceAccountFilepath[] = ""

inlineconstexpr

kDefaultsFilePath

constexpr char cuttlefish::kDefaultsFilePath[]

constexpr

Initial value:

=
    "/usr/lib/cuttlefish-common/etc/cf_defaults"

kDefaultTargetDirectory

constexpr char cuttlefish::kDefaultTargetDirectory[] = ""

inlineconstexpr

kDefaultTargetZip

constexpr char cuttlefish::kDefaultTargetZip[] = "default_target_zip"

staticconstexpr

kDefaultUseGceMetadata

constexpr bool cuttlefish::kDefaultUseGceMetadata = false

inlineconstexpr

kDefaultUuidPrefix

constexpr char cuttlefish::kDefaultUuidPrefix[]

inlineconstexpr

Initial value:

=
    "699acfc4-c8c4-11e7-882b-5065f31dc1"

kDefaultWaitRetryPeriod

constexpr std::chrono::seconds cuttlefish::kDefaultWaitRetryPeriod

inlineconstexpr

Initial value:

=
    std::chrono::seconds(20)

kDeviceType

constexpr char cuttlefish::kDeviceType[] = "device_type"

staticconstexpr

kDisplayConfigs

constexpr char cuttlefish::kDisplayConfigs[] = "display_configs"

staticconstexpr

kDisplayFlag

constexpr const char cuttlefish::kDisplayFlag[] = "display"

constexpr

kDisplayHelp

constexpr const char cuttlefish::kDisplayHelp[]

constexpr

Initial value:

=
    "Comma separated key=value pairs of display properties. Supported "
    "properties:\n"
    " 'width': required, width of the display in pixels\n"
    " 'height': required, height of the display in pixels\n"
    " 'dpi': optional, default 320, density of the display\n"
    " 'refresh_rate_hz': optional, default 60, display refresh rate in Hertz\n"
    ". Example usage: \n"
    "--display=width=1280,height=720\n"
    "--display=width=1440,height=900,dpi=480,refresh_rate_hz=30\n"

kDisplayPowerModeChangedMessage

constexpr char cuttlefish::kDisplayPowerModeChangedMessage[]

inlineconstexpr

Initial value:

=
    "VIRTUAL_DEVICE_DISPLAY_POWER_MODE_CHANGED"

kDomkeyMappingConfig

constexpr char cuttlefish::kDomkeyMappingConfig[] = "domkey_mapping_config"

staticconstexpr

kDpi

constexpr char cuttlefish::kDpi[] = "dpi"

staticconstexpr

kEcioUnknownValue

constexpr int cuttlefish::kEcioUnknownValue = -1

constexpr

kEmergencyMode

constexpr char cuttlefish::kEmergencyMode[] = "emergency_mode"

staticconstexpr

kEmptyKmlText

char cuttlefish::kEmptyKmlText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "</kml>"

kEmptyRteTrkText

char cuttlefish::kEmptyRteTrkText[]

Initial value:

=
    "<?xml version=\"1.0\"?>"
    "<gpx>"
    "<rte>"
    "</rte>"
    "<trk>"
    "<trkseg>"
    "</trkseg>"
    "</trk>"
    "</gpx>"

kEmptyText

char cuttlefish::kEmptyText[]

Initial value:

=
    "<?xml version=\"1.0\"?>"
    "<gpx>"
    "</gpx>"

kEnableAudio

constexpr char cuttlefish::kEnableAudio[] = "enable_audio"

staticconstexpr

kEnableAutomotiveProxy

constexpr char cuttlefish::kEnableAutomotiveProxy[] = "enable_automotive_proxy"

staticconstexpr

kEnableBootAnimation

constexpr char cuttlefish::kEnableBootAnimation[] = "enable_bootanimation"

staticconstexpr

kEnableGamepad

constexpr char cuttlefish::kEnableGamepad[] = "enable_gamepad"

staticconstexpr

kEnableGnssGrpcProxy

constexpr char cuttlefish::kEnableGnssGrpcProxy[] = "enable_gnss_grpc_proxy"

staticconstexpr

kEnableGpuExternalBlob

constexpr char cuttlefish::kEnableGpuExternalBlob[] = "enable_gpu_external_blob"

staticconstexpr

kEnableGpuSystemBlob

constexpr char cuttlefish::kEnableGpuSystemBlob[] = "enable_gpu_system_blob"

staticconstexpr

kEnableGpuUdmabuf

constexpr char cuttlefish::kEnableGpuUdmabuf[] = "enable_gpu_udmabuf"

staticconstexpr

kEnableGpuVhostUser

constexpr char cuttlefish::kEnableGpuVhostUser[] = "enable_gpu_vhost_user"

staticconstexpr

kEnableHostNfc

constexpr char cuttlefish::kEnableHostNfc[] = "enable_host_nfc"

staticconstexpr

kEnableHostNfcConnector

constexpr char cuttlefish::kEnableHostNfcConnector[] = "enable_host_nfc_connector"

staticconstexpr

kEnableHostUwb

constexpr char cuttlefish::kEnableHostUwb[] = "enable_host_uwb"

staticconstexpr

kEnableHostUwbConnector

constexpr char cuttlefish::kEnableHostUwbConnector[] = "enable_host_uwb_connector"

staticconstexpr

kEnableJcardSimulator

constexpr char cuttlefish::kEnableJcardSimulator[] = "enable_jcard_simulator"

staticconstexpr

kEnableKernelLog

constexpr char cuttlefish::kEnableKernelLog[] = "enable_kernel_log"

staticconstexpr

kEnableMinimalMode

constexpr char cuttlefish::kEnableMinimalMode[] = "enable_minimal_mode"

staticconstexpr

kEnableModemNetsim

constexpr char cuttlefish::kEnableModemNetsim[] = "enable_modem_netsim"

staticconstexpr

kEnableMouse

constexpr char cuttlefish::kEnableMouse[] = "enable_mouse"

staticconstexpr

kEnablePkvm

constexpr char cuttlefish::kEnablePkvm[] = "enable_pkvm"

staticconstexpr

kEnableSandbox

constexpr char cuttlefish::kEnableSandbox[] = "enable_sandbox"

staticconstexpr

kEnableTapDevices

constexpr char cuttlefish::kEnableTapDevices[] = "enable_tap_devices"

staticconstexpr

kEnableUsb

constexpr char cuttlefish::kEnableUsb[] = "enable_usb"

staticconstexpr

kEnableVhalProxyServer

constexpr char cuttlefish::kEnableVhalProxyServer[] = "enable_vhal_proxy_server"

staticconstexpr

kEnableVirtiofs

constexpr char cuttlefish::kEnableVirtiofs[] = "enable_virtiofs"

staticconstexpr

kEnableWifi

constexpr char cuttlefish::kEnableWifi[] = "enable_wifi"

staticconstexpr

kEnvironmentName

constexpr char cuttlefish::kEnvironmentName[] = "environment_name"

staticconstexpr

kEnvironmentsUdsDir

constexpr char cuttlefish::kEnvironmentsUdsDir[] = "environments_uds_dir"

staticconstexpr

kEthernetBridgeName

constexpr char cuttlefish::kEthernetBridgeName[] = "ethernet_bridge_name"

staticconstexpr

kEthernetConnectedMessage

constexpr char cuttlefish::kEthernetConnectedMessage[]

inlineconstexpr

Initial value:

=
    "VIRTUAL_DEVICE_NETWORK_ETHERNET_CONNECTED"

kEthernetIp

constexpr char cuttlefish::kEthernetIp[] = "192.168.98"

inlineconstexpr

kEthernetIPV6

constexpr char cuttlefish::kEthernetIPV6[] = "ethernet_ipv6"

staticconstexpr

kEthernetMac

constexpr char cuttlefish::kEthernetMac[] = "ethernet_mac"

staticconstexpr

kEthernetTapName

constexpr char cuttlefish::kEthernetTapName[] = "ethernet_tap_name"

staticconstexpr

kExternalNetworkMode

constexpr char cuttlefish::kExternalNetworkMode[] = "external_network_mode"

staticconstexpr

kExtraBootconfigArgsInstanced

constexpr char cuttlefish::kExtraBootconfigArgsInstanced[] = "extra_bootconfig_args"

staticconstexpr

kExtraKernelCmdline

constexpr char cuttlefish::kExtraKernelCmdline[] = "extra_kernel_cmdline"

staticconstexpr

kFailFast

constexpr char cuttlefish::kFailFast[] = "fail_fast"

staticconstexpr

kFastbootdStartedMessage

constexpr char cuttlefish::kFastbootdStartedMessage[]

inlineconstexpr

Initial value:

=
    "init: starting service 'fastbootd'..."

kFastbootHostPort

constexpr char cuttlefish::kFastbootHostPort[] = "fastboot_host_port"

staticconstexpr

kFastbootStartedMessage

constexpr char cuttlefish::kFastbootStartedMessage[]

inlineconstexpr

Initial value:

=
    "Listening for fastboot command on tcp"

kFetcherConfigFile

constexpr std::string_view cuttlefish::kFetcherConfigFile = "fetcher_config.json"

staticconstexpr

kFilenameEncryptionMode

constexpr char cuttlefish::kFilenameEncryptionMode[] = "filename_encryption_mode"

staticconstexpr

kFileSeverityEnvVar

constexpr const char* cuttlefish::kFileSeverityEnvVar = "CF_FILE_SEVERITY"

constexpr

kFixedLocationFilePath

constexpr char cuttlefish::kFixedLocationFilePath[] = "fixed_location_file_path"

staticconstexpr

kFlagCasAddr

constexpr char cuttlefish::kFlagCasAddr[] = "cas-addr"

inlineconstexpr

kFlagCasInstance

constexpr char cuttlefish::kFlagCasInstance[] = "cas-instance"

inlineconstexpr

kFlagDigest

constexpr char cuttlefish::kFlagDigest[] = "digest"

inlineconstexpr

kFlagDir

constexpr char cuttlefish::kFlagDir[] = "dir"

inlineconstexpr

kFlagDisableCache

constexpr char cuttlefish::kFlagDisableCache[] = "disable-cache"

inlineconstexpr

kFlagDumpJson

constexpr char cuttlefish::kFlagDumpJson[] = "dump-json"

inlineconstexpr

kFlagModemSimulatorSimType

constexpr char cuttlefish::kFlagModemSimulatorSimType[] = "modem_simulator_sim_type"

inlineconstexpr

kFlagServiceAccountJson

constexpr char cuttlefish::kFlagServiceAccountJson[] = "service-account-json"

inlineconstexpr

kFlagUseAdc

constexpr char cuttlefish::kFlagUseAdc[] = "use-adc"

inlineconstexpr

kFleetSubcmd

constexpr char cuttlefish::kFleetSubcmd[] = "fleet"

constexpr

kFoldableInstanceTemplate

constexpr std::string_view cuttlefish::kFoldableInstanceTemplate

staticconstexpr

kFooterSizeBytes

constexpr int cuttlefish::kFooterSizeBytes = 14

constexpr

kFragments

constexpr char cuttlefish::kFragments[] = "fragments"

staticconstexpr

kFrameSockPath

constexpr char cuttlefish::kFrameSockPath[] = "frame_sock_path"

staticconstexpr

kFuchsiaMultibootBinPath

constexpr char cuttlefish::kFuchsiaMultibootBinPath[] = "multiboot_bin_path"

staticconstexpr

kFuchsiaRootImage

constexpr char cuttlefish::kFuchsiaRootImage[] = "fuchsia_root_image"

staticconstexpr

kFuchsiaZedbootPath

constexpr char cuttlefish::kFuchsiaZedbootPath[] = "fuchsia_zedboot_path"

staticconstexpr

kGblFastbootStartedMessage

constexpr char cuttlefish::kGblFastbootStartedMessage[]

inlineconstexpr

Initial value:

=
    "Started Fastboot over TCP"

kGdbPort

constexpr char cuttlefish::kGdbPort[] = "gdb_port"

staticconstexpr

kGem5BinaryDir

constexpr char cuttlefish::kGem5BinaryDir[] = "gem5_binary_dir"

staticconstexpr

kGem5CheckpointDir

constexpr char cuttlefish::kGem5CheckpointDir[] = "gem5_checkpoint_dir"

staticconstexpr

kGem5DebugFile

constexpr char cuttlefish::kGem5DebugFile[] = "gem5_debug_file"

staticconstexpr

kGem5DebugFlags

constexpr char cuttlefish::kGem5DebugFlags[] = "gem5_debug_flags"

staticconstexpr

kGnssFilePath

constexpr char cuttlefish::kGnssFilePath[] = "gnss_file_path"

staticconstexpr

kGnssGrpcProxyServerPort

constexpr char cuttlefish::kGnssGrpcProxyServerPort[]

staticconstexpr

Initial value:

=
    "gnss_grpc_proxy_server_port"

kGoInstanceTemplate

constexpr std::string_view cuttlefish::kGoInstanceTemplate

staticconstexpr

Initial value:

= R""""(
{
    "vm": {
        "memory_mb": 2048
    },
    "graphics":{
        "displays":[
            {
                "width": 720,
                "height": 1280,
                "dpi": 320
            }
        ]
    }
}
  )""""

kGpuAngleFeatureOverridesDisabled

constexpr char cuttlefish::kGpuAngleFeatureOverridesDisabled[]

staticconstexpr

Initial value:

=
    "gpu_angle_feature_overrides_disabled"

kGpuAngleFeatureOverridesEnabled

constexpr char cuttlefish::kGpuAngleFeatureOverridesEnabled[]

staticconstexpr

Initial value:

=
    "gpu_angle_feature_overrides_enabled"

kGpuCaptureBinary

constexpr char cuttlefish::kGpuCaptureBinary[] = "gpu_capture_binary"

staticconstexpr

kGpuContextTypes

constexpr char cuttlefish::kGpuContextTypes[] = "gpu_context_types"

staticconstexpr

kGpuGfxstreamTransport

constexpr char cuttlefish::kGpuGfxstreamTransport[] = "gpu_gfxstream_transport"

staticconstexpr

kGpuMode

constexpr char cuttlefish::kGpuMode[] = "gpu_mode"

staticconstexpr

kGpuModeAuto

constexpr std::string_view cuttlefish::kGpuModeAuto = "auto"

inlineconstexpr

kGpuModeCandidates

constexpr char cuttlefish::kGpuModeCandidates[] = "gpu_mode_candidates"

staticconstexpr

kGpuModeCustom

constexpr std::string_view cuttlefish::kGpuModeCustom = "custom"

inlineconstexpr

kGpuModeDrmVirgl

constexpr std::string_view cuttlefish::kGpuModeDrmVirgl = "drm_virgl"

inlineconstexpr

kGpuModeGfxstream

constexpr std::string_view cuttlefish::kGpuModeGfxstream = "gfxstream"

inlineconstexpr

kGpuModeGfxstreamGuestAngle

constexpr std::string_view cuttlefish::kGpuModeGfxstreamGuestAngle

inlineconstexpr

Initial value:

=
    "gfxstream_guest_angle"

kGpuModeGfxstreamGuestAngleHostLavapipe

constexpr std::string_view cuttlefish::kGpuModeGfxstreamGuestAngleHostLavapipe

inlineconstexpr

Initial value:

=
    "gfxstream_guest_angle_host_lavapipe"

kGpuModeGfxstreamGuestAngleHostSwiftshader

constexpr std::string_view cuttlefish::kGpuModeGfxstreamGuestAngleHostSwiftshader

inlineconstexpr

Initial value:

=
    "gfxstream_guest_angle_host_swiftshader"

kGpuModeGuestLavapipe

constexpr std::string_view cuttlefish::kGpuModeGuestLavapipe = "guest_lavapipe"

inlineconstexpr

kGpuModeGuestSwiftshader

constexpr std::string_view cuttlefish::kGpuModeGuestSwiftshader

inlineconstexpr

Initial value:

=
    "guest_swiftshader"

kGpuModeNone

constexpr std::string_view cuttlefish::kGpuModeNone = "none"

inlineconstexpr

kGpuRendererFeatures

constexpr char cuttlefish::kGpuRendererFeatures[] = "gpu_renderer_features"

staticconstexpr

kGpuVhostUserModeAuto

constexpr char cuttlefish::kGpuVhostUserModeAuto[] = "auto"

inlineconstexpr

kGpuVhostUserModeOff

constexpr char cuttlefish::kGpuVhostUserModeOff[] = "off"

inlineconstexpr

kGpuVhostUserModeOn

constexpr char cuttlefish::kGpuVhostUserModeOn[] = "on"

inlineconstexpr

kGroupUuid

constexpr char cuttlefish::kGroupUuid[] = "group_uuid"

staticconstexpr

kGrpcConfig

constexpr char cuttlefish::kGrpcConfig[] = "grpc_config"

staticconstexpr

kGrpcSocketDirName

constexpr char cuttlefish::kGrpcSocketDirName[] = "grpc_socket"

inlineconstexpr

kGrubConfigDestDirectoryPath

constexpr char cuttlefish::kGrubConfigDestDirectoryPath[] = "/boot/grub"

staticconstexpr

kGrubConfigDestPath

constexpr char cuttlefish::kGrubConfigDestPath[] = "/boot/grub/grub.cfg"

staticconstexpr

kGrubDebianConfigDestPath

constexpr char cuttlefish::kGrubDebianConfigDestPath[] = "/EFI/debian/grub.cfg"

staticconstexpr

kGrubModules

constexpr std::array cuttlefish::kGrubModules

staticconstexpr

Initial value:

{
    "normal", "configfile", "linux", "multiboot",  "ls",
    "cat",    "help",       "fat",   "part_msdos", "part_gpt"}

kGrubModulesPath

constexpr char cuttlefish::kGrubModulesPath[] = "/usr/lib/grub"

staticconstexpr

kGrubModulesX64Name

constexpr char cuttlefish::kGrubModulesX64Name[] = "x86_64-efi"

staticconstexpr

kGrubUbuntuConfigDestPath

constexpr char cuttlefish::kGrubUbuntuConfigDestPath[] = "/EFI/ubuntu/grub.cfg"

staticconstexpr

kGuestAndroidVersion

constexpr char cuttlefish::kGuestAndroidVersion[] = "guest_android_version"

staticconstexpr

kGuestEnforceSecurity

constexpr char cuttlefish::kGuestEnforceSecurity[] = "guest_enforce_security"

staticconstexpr

kGuestHwuiRenderer

constexpr char cuttlefish::kGuestHwuiRenderer[] = "guest_hwui_renderer"

staticconstexpr

kGuestRendererPreload

constexpr char cuttlefish::kGuestRendererPreload[] = "guest_renderer_preload"

staticconstexpr

kGuestSnapshotBase

constexpr const char cuttlefish::kGuestSnapshotBase[] = "guest_vm"

inlineconstexpr

kGuestSnapshotField

constexpr const char cuttlefish::kGuestSnapshotField[] = "guest_snapshot"

inlineconstexpr

kGuestUsesBgraFramebuffers

constexpr char cuttlefish::kGuestUsesBgraFramebuffers[]

staticconstexpr

Initial value:

=
    "guest_uses_bgra_framebuffers"

kHasBluetooth

constexpr char cuttlefish::kHasBluetooth[] = "has_bluetooth"

staticconstexpr

kHasVulkanGfxstreamApex

constexpr char cuttlefish::kHasVulkanGfxstreamApex[] = "has_vulkan_gfxstream_apex"

staticconstexpr

kHasVulkanLavapipeApex

constexpr char cuttlefish::kHasVulkanLavapipeApex[] = "has_vulkan_lavapipe_apex"

staticconstexpr

kHasVulkanSwiftshaderApex

constexpr char cuttlefish::kHasVulkanSwiftshaderApex[]

staticconstexpr

Initial value:

=
    "has_vulkan_swiftshader_apex"

kHasWifi

constexpr char cuttlefish::kHasWifi[] = "has_wifi_card"

staticconstexpr

kHelp

constexpr char cuttlefish::kHelp[]

staticconstexpr

Initial value:

= R"(
    This program launches and automatically restarts the input command
    following the selected restart conditions.
    Example usage:
 
      ./process_restarter -when_dumped -- my_program --arg1 --arg2)"

kHelpMessage

constexpr char cuttlefish::kHelpMessage[]

staticconstexpr

Initial value:

= R"(
usage: cvd fleet [--help]
 
  cvd fleet will list the active devices with information.
)"

kHibernationExitMessage

constexpr char cuttlefish::kHibernationExitMessage[]

inlineconstexpr

Initial value:

=
    "PM: hibernation: hibernation exit"

kHostPort

constexpr char cuttlefish::kHostPort[] = "adb_host_port"

staticconstexpr

kHostToolsSubdirectory

constexpr char cuttlefish::kHostToolsSubdirectory[] = "host_tools"

inlinestaticconstexpr

kHostToolsVersion

constexpr char cuttlefish::kHostToolsVersion[] = "host_tools_version"

staticconstexpr

kHWComposer

constexpr char cuttlefish::kHWComposer[] = "hwcomposer"

staticconstexpr

kHwComposerAuto

constexpr char cuttlefish::kHwComposerAuto[] = "auto"

inlineconstexpr

kHwComposerDrm

constexpr char cuttlefish::kHwComposerDrm[] = "drm_hwcomposer"

inlineconstexpr

kHwComposerNone

constexpr char cuttlefish::kHwComposerNone[] = "none"

inlineconstexpr

kHwComposerRanchu

constexpr char cuttlefish::kHwComposerRanchu[] = "ranchu"

inlineconstexpr

kIgnoreSigtstpHelp

constexpr char cuttlefish::kIgnoreSigtstpHelp[]

staticconstexpr

Initial value:

=
    "Ignore the sigtstp. This is useful when the managed processes are crosvm"
    "Crosvm has its own logic to be suspended."

kImageName

constexpr char cuttlefish::kImageName[] = "chromeos_state.img"

staticconstexpr

kImagesDir

constexpr char cuttlefish::kImagesDir[] = "images_dir"

staticconstexpr

kImageSizeMb

constexpr int cuttlefish::kImageSizeMb = 8096

staticconstexpr

kInitBootImage

constexpr char cuttlefish::kInitBootImage[] = "init_boot_image"

staticconstexpr

kInitramfsPath

constexpr char cuttlefish::kInitramfsPath[] = "initramfs_path"

staticconstexpr

kInitrdDestPath

constexpr char cuttlefish::kInitrdDestPath[] = "/initrd"

staticconstexpr

kInstanceDir

constexpr char cuttlefish::kInstanceDir[] = "instance_dir"

staticconstexpr

kInstanceNames

constexpr char cuttlefish::kInstanceNames[] = "instance_names"

staticconstexpr

kInstances

constexpr char cuttlefish::kInstances[] = "instances"

staticconstexpr

kInstancesUdsDir

constexpr char cuttlefish::kInstancesUdsDir[] = "instances_uds_dir"

staticconstexpr

kInternalDirName

constexpr char cuttlefish::kInternalDirName[] = "internal"

inlineconstexpr

kInternalGroupName

constexpr char cuttlefish::kInternalGroupName[] = "cvd"

inlineconstexpr

kJsIndexToLinuxMapping

const std::array<uint16_t, 17> cuttlefish::kJsIndexToLinuxMapping

static

Initial value:

= {
    BTN_SOUTH, BTN_EAST, BTN_WEST,   BTN_NORTH, BTN_TL,     BTN_TR,
    0,         0,        BTN_SELECT, BTN_START, BTN_THUMBL, BTN_THUMBR,
    KEY_UP,    KEY_DOWN, KEY_LEFT,   KEY_RIGHT, BTN_MODE}

kKernelDestPath

constexpr char cuttlefish::kKernelDestPath[] = "/vmlinuz"

staticconstexpr

kKernelLoadedMessage

constexpr char cuttlefish::kKernelLoadedMessage[] = "] Linux version"

inlineconstexpr

kKernelPath

constexpr char cuttlefish::kKernelPath[] = "kernel_path"

staticconstexpr

kKeyDownloaderPath

constexpr char cuttlefish::kKeyDownloaderPath[] = "downloader-path"

inlineconstexpr

kKeyFlags

constexpr char cuttlefish::kKeyFlags[] = "flags"

inlineconstexpr

kKgdb

constexpr char cuttlefish::kKgdb[] = "kgdb"

staticconstexpr

kKvmPath

constexpr char cuttlefish::kKvmPath[] = "kvm_path"

staticconstexpr

kLightsServerPort

constexpr char cuttlefish::kLightsServerPort[] = "lights_server_port"

staticconstexpr

kLinuxInitramfsPath

constexpr char cuttlefish::kLinuxInitramfsPath[] = "linux_initramfs_path"

staticconstexpr

kLinuxKernelPath

constexpr char cuttlefish::kLinuxKernelPath[] = "linux_kernel_path"

staticconstexpr

kLinuxRootImage

constexpr char cuttlefish::kLinuxRootImage[] = "linux_root_image"

staticconstexpr

kLocationMissingFieldsText

char cuttlefish::kLocationMissingFieldsText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<Placemark>"
    "<Point>"
    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
    "</Point>"
    "</Placemark>"
    "</kml>"

kLocationMissingLongitudeLatitudeText

char cuttlefish::kLocationMissingLongitudeLatitudeText[]

Initial value:

=
    "<?xml version=\"1.0\"?>"
    "<gpx>"
    "<wpt lon=\"9.81\">"
    "<ele>6.02</ele>"
    "<name>Name</name>"
    "<desc>Desc</desc>"
    "</wpt>"
    "</gpx>"

kLocationMissingLongitudeText

char cuttlefish::kLocationMissingLongitudeText[]

Initial value:

=
    "<?xml version=\"1.0\"?>"
    "<gpx>"
    "<wpt lat=\"3.1415\">"
    "<ele>6.02</ele>"
    "<name>Name</name>"
    "<desc>Desc</desc>"
    "</wpt>"
    "</gpx>"

kLocationMissingRequiredFieldsText

char cuttlefish::kLocationMissingRequiredFieldsText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<Placemark>"
    "<name>Simple placemark</name>"
    "<description>Attached to the ground.</description>"
    "</Placemark>"
    "</kml>"

kLocationNameOnlyFirstText

char cuttlefish::kLocationNameOnlyFirstText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<Placemark>"
    "<name>Simple placemark</name>kk0"
    "<description>Attached to the ground.</description>"
    "<LineString>"
    "<coordinates>-122.0822035425683,37.42228990140251,0\
                  -122.0822035425683,37.42228990140251,0</coordinates>"
    "</LineString>"
    "</Placemark>"
    "</kml>"

kLocationNormalText

char cuttlefish::kLocationNormalText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<Placemark>"
    "<name>Simple placemark</name>"
    "<description>Attached to the ground.</description>"
    "<Point>"
    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
    "</Point>"
    "</Placemark>"
    "</kml>"

kLogcatSerialMode

constexpr char cuttlefish::kLogcatSerialMode[] = "serial"

inlineconstexpr

kLogcatVsockMode

constexpr char cuttlefish::kLogcatVsockMode[] = "vsock"

inlineconstexpr

kLogDirName

constexpr char cuttlefish::kLogDirName[] = "logs"

inlineconstexpr

kLogNameAssembleCvd

constexpr char cuttlefish::kLogNameAssembleCvd[] = "assemble_cvd.log"

inlineconstexpr

kLogNameBuildInfo

constexpr char cuttlefish::kLogNameBuildInfo[] = "build_info.log"

inlineconstexpr

kLogNameCrosvmOpenWrt

constexpr char cuttlefish::kLogNameCrosvmOpenWrt[] = "crosvm_openwrt.log"

inlineconstexpr

kLogNameCrosvmOpenWrtBoot

constexpr char cuttlefish::kLogNameCrosvmOpenWrtBoot[] = "crosvm_openwrt_boot.log"

inlineconstexpr

kLogNameFetch

constexpr char cuttlefish::kLogNameFetch[] = "fetch.log"

inlineconstexpr

kLogNameKernel

constexpr char cuttlefish::kLogNameKernel[] = "kernel.log"

inlineconstexpr

kLogNameLauncher

constexpr char cuttlefish::kLogNameLauncher[] = "launcher.log"

inlineconstexpr

kLogNameLogcat

constexpr char cuttlefish::kLogNameLogcat[] = "logcat"

inlineconstexpr

kLogNameMetrics

constexpr char cuttlefish::kLogNameMetrics[] = "metrics.log"

inlineconstexpr

kLogNameMetricsV2

constexpr char cuttlefish::kLogNameMetricsV2[] = "metrics_v2.log"

inlineconstexpr

kLogNameModemSimulator

constexpr char cuttlefish::kLogNameModemSimulator[] = "modem_simulator.log"

inlineconstexpr

kLz4LegacyFrameBlockSize

constexpr uint32_t cuttlefish::kLz4LegacyFrameBlockSize = 8 << 20

constexpr

kMaxAvbMetadataSize

constexpr uint64_t cuttlefish::kMaxAvbMetadataSize = 69632ul

inlineconstexpr

kMaxCommandLength

constexpr int32_t cuttlefish::kMaxCommandLength = 4096

constexpr

kMaxIfaceNameId

constexpr uint32_t cuttlefish::kMaxIfaceNameId = 63

inlineconstexpr

kMaxLogicalChannels

constexpr int cuttlefish::kMaxLogicalChannels = 3

constexpr

kMaxNumberSizeBytes

constexpr int cuttlefish::kMaxNumberSizeBytes = 11

constexpr

kMcu

constexpr char cuttlefish::kMcu[] = "mcu"

staticconstexpr

kMediaConfigs

constexpr char cuttlefish::kMediaConfigs[] = "media_configs"

staticconstexpr

kMediaFlag

constexpr const char cuttlefish::kMediaFlag[] = "media"

constexpr

kMediaHelp

constexpr const char cuttlefish::kMediaHelp[]

constexpr

Initial value:

=
    "Colon separated media device properties: "
    "\"[type]:[key1]=[val1]:[key2]=[val2]\". "
    "Supported types:\n"
    "    'v4l2_emulated_camera_splane': emulated media capture device "
    "(single-plane)\n"
    "    'v4l2_emulated_camera_mplane': emulated media capture device "
    "(multi-plane)\n"
    "    'v4l2_proxy': proxy a host V4L2 device into the guest\n"
    "    'v4l2_stream_proxy': stream video from a host named pipe into the "
    "guest\n\n"
    "v4l2_stream_proxy properties:\n"
    "    'input_path': path to the host named pipe\n"
    "    'input_width': width of the video stream in pixels\n"
    "    'input_height': height of the video stream in pixels\n"
    "    'input_fps': frames per second (e.g., 30 or 30000/1001)\n\n"
    "Supported keys:\n"
    "    'lens_facing': optional, supported values: 'FRONT', 'BACK', "
    "'EXTERNAL'\n\n"
    "Example usage:\n"
    "  --media=v4l2_emulated_camera_mplane:lens_facing=BACK\n"
    "  --media=v4l2_stream_proxy:input_path=/tmp/fifo:"
    "input_width=640:input_height=480:input_fps=30\n"

kMediaInputFps

constexpr char cuttlefish::kMediaInputFps[] = "input_fps"

staticconstexpr

kMediaInputHeight

constexpr char cuttlefish::kMediaInputHeight[] = "input_height"

staticconstexpr

kMediaInputPath

constexpr char cuttlefish::kMediaInputPath[] = "input_path"

staticconstexpr

kMediaInputWidth

constexpr char cuttlefish::kMediaInputWidth[] = "input_width"

staticconstexpr

kMediaLensFacing

constexpr char cuttlefish::kMediaLensFacing[] = "lens_facing"

staticconstexpr

kMediaType

constexpr char cuttlefish::kMediaType[] = "type"

staticconstexpr

kMediaTypeV4l2EmulatedCameraMPlane

constexpr char cuttlefish::kMediaTypeV4l2EmulatedCameraMPlane[]

staticconstexpr

Initial value:

=
    "v4l2_emulated_camera_mplane"

kMediaTypeV4l2EmulatedCameraSPlane

constexpr char cuttlefish::kMediaTypeV4l2EmulatedCameraSPlane[]

staticconstexpr

Initial value:

=
    "v4l2_emulated_camera_splane"

kMediaTypeV4l2Proxy

constexpr char cuttlefish::kMediaTypeV4l2Proxy[] = "v4l2_proxy"

staticconstexpr

kMediaTypeV4l2Stream

constexpr char cuttlefish::kMediaTypeV4l2Stream[] = "v4l2_stream_proxy"

staticconstexpr

kMemoryMb

constexpr char cuttlefish::kMemoryMb[] = "memory_mb"

staticconstexpr

kMetadataImageBytes

constexpr size_t cuttlefish::kMetadataImageBytes = kMetadataImageMb << 20

staticconstexpr

kMetadataImageMb

constexpr size_t cuttlefish::kMetadataImageMb = 64

staticconstexpr

kMetaInfoJsonFileName

constexpr const char cuttlefish::kMetaInfoJsonFileName[] = "snapshot_meta_info.json"

inlineconstexpr

kMinCacheMaxSize

constexpr int64_t cuttlefish::kMinCacheMaxSize = 8LL * 1024 * 1024 * 1024

inlineconstexpr

kMinReadSize

constexpr size_t cuttlefish::kMinReadSize = 1 << 26

staticconstexpr

kMobileBridgeName

constexpr char cuttlefish::kMobileBridgeName[] = "mobile_bridge_name"

staticconstexpr

kMobileIp

constexpr char cuttlefish::kMobileIp[] = "192.168.97"

inlineconstexpr

kMobileMac

constexpr char cuttlefish::kMobileMac[] = "mobile_mac"

staticconstexpr

kMobileNetworkConnectedMessage

constexpr char cuttlefish::kMobileNetworkConnectedMessage[]

inlineconstexpr

Initial value:

=
    "VIRTUAL_DEVICE_NETWORK_MOBILE_CONNECTED"

kMobileTapName

constexpr char cuttlefish::kMobileTapName[] = "mobile_tap_name"

staticconstexpr

kModemSimulatorId

constexpr char cuttlefish::kModemSimulatorId[] = "modem_simulator_host_id"

staticconstexpr

kModemSimulatorInstanceNumber

constexpr char cuttlefish::kModemSimulatorInstanceNumber[]

staticconstexpr

Initial value:

=
    "modem_simulator_instance_number"

kModemSimulatorPorts

constexpr char cuttlefish::kModemSimulatorPorts[] = "modem_simulator_ports"

staticconstexpr

kModemSimulatorSimType

constexpr char cuttlefish::kModemSimulatorSimType[] = "modem_simulator_sim_type"

staticconstexpr

kModemTechnoloy

constexpr char cuttlefish::kModemTechnoloy[] = "modem_technoloy"

staticconstexpr

kMte

constexpr char cuttlefish::kMte[] = "mte"

staticconstexpr

kMultibootBinDestPath

constexpr char cuttlefish::kMultibootBinDestPath[] = "/multiboot.bin"

staticconstexpr

kMultibootModuleDestPath

constexpr char cuttlefish::kMultibootModuleDestPath[] = "/EFI/modules/multiboot.mod"

staticconstexpr

kMultibootModuleSrcPathAA64

constexpr char cuttlefish::kMultibootModuleSrcPathAA64[]

staticconstexpr

Initial value:

=
    "/usr/lib/grub/arm64-efi/multiboot.mod"

kMultibootModuleSrcPathX64

constexpr char cuttlefish::kMultibootModuleSrcPathX64[]

staticconstexpr

Initial value:

=
    "/usr/lib/grub/x86_64-efi/multiboot.mod"

kMultipleCoordinatesText

char cuttlefish::kMultipleCoordinatesText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<Placemark>"
    "<LineString>"
    "<coordinates>-122.0822035425683,37.42228990140251,0 \
                  10.4,39.,20\t\t0,21.4,1"
    "</coordinates>"
    "</LineString>"
    "</Placemark>"
    "</kml>"

kMultipleLocationsText

char cuttlefish::kMultipleLocationsText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<Placemark>"
    "<name>Simple placemark</name>"
    "<description>Attached to the ground.</description>"
    "<Point>"
    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
    "</Point>"
    "</Placemark>"
    "<Placemark>"
    "<name>Simple placemark</name>"
    "<description>Attached to the ground.</description>"
    "<Point>"
    "<coordinates>-122.0822035425683,37.42228990140251,0\
                  -122.0822035425683,37.42228990140251,0</coordinates>"
    "</Point>"
    "</Placemark>"
    "<Placemark>"
    "<name>Simple placemark</name>"
    "<description>Attached to the ground.</description>"
    "<Point>"
    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
    "</Point>"
    "</Placemark>"
    "</kml>"

kName

constexpr std::string_view cuttlefish::kName = "android_esp"

staticconstexpr

kNestedDocText

char cuttlefish::kNestedDocText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<Document>"
    "<Folder>"
    "<name>Placemarks</name>"
    "<description>These are just some of the different kinds of placemarks "
    "with"
    "which you can mark your favorite places</description>"
    "<LookAt>"
    "<longitude>-122.0839597145766</longitude>"
    "<latitude>37.42222904525232</latitude>"
    "<altitude>0</altitude>"
    "<heading>-148.4122922628044</heading>"
    "<tilt>40.5575073395506</tilt>"
    "<range>500.6566641072245</range>"
    "</LookAt>"
    "<Placemark>"
    "<name>Simple placemark</name>"
    "<description>Attached to the ground.</description>"
    "<Point>"
    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
    "</Point>"
    "</Placemark>"
    "</Folder>"
    "</Document>"
    "</kml>"

kNetsimArgs

constexpr char cuttlefish::kNetsimArgs[] = "netsim_args"

staticconstexpr

kNetsimConnectorInstanceNum

constexpr char cuttlefish::kNetsimConnectorInstanceNum[]

staticconstexpr

Initial value:

=
    "netsim_connector_instance_num"

kNetsimInstanceNum

constexpr char cuttlefish::kNetsimInstanceNum[] = "netsim_instance_num"

staticconstexpr

kNetworkSelectionMode

constexpr char cuttlefish::kNetworkSelectionMode[] = "network_selection_mode"

staticconstexpr

kNewDataImage

constexpr char cuttlefish::kNewDataImage[] = "new_data_image"

staticconstexpr

kNewSuperImage

constexpr char cuttlefish::kNewSuperImage[] = "new_super_image"

staticconstexpr

kNewVbmetaImage

constexpr char cuttlefish::kNewVbmetaImage[] = "new_vbmeta_image"

staticconstexpr

kNewVbmetaSystemDlkmImage

constexpr char cuttlefish::kNewVbmetaSystemDlkmImage[]

staticconstexpr

Initial value:

=
    "new_vbmeta_system_dlkm_image"

kNewVbmetaVendorDlkmImage

constexpr char cuttlefish::kNewVbmetaVendorDlkmImage[]

staticconstexpr

Initial value:

=
    "new_vbmeta_vendor_dlkm_image"

kNewVendorBootImage

constexpr char cuttlefish::kNewVendorBootImage[] = "new_vendor_boot_image"

staticconstexpr

kNoPlacemarksText

char cuttlefish::kNoPlacemarksText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<LineString></LineString>"
    "<name></name>"
    "</kml>"

kNullAttributeText

char cuttlefish::kNullAttributeText[]

Initial value:

=
    "<?xml version=\"1.0\"?>"
    "<gpx>"
    "<wpt lon=\"0\" lat=\"0\">"
    "<name/>"
    "</wpt>"
    "</gpx>"

kNullNameNoCrashText

char cuttlefish::kNullNameNoCrashText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<Placemark>"
    "<name/>"
    "<description/>"
    "<Point>"
    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
    "</Point>"
    "</Placemark>"
    "</kml>"

kNullPadLength

constexpr size_t cuttlefish::kNullPadLength = 1

staticconstexpr

kOneCoordinateText

char cuttlefish::kOneCoordinateText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<Placemark>"
    "<Point>"
    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
    "</Point>"
    "</Placemark>"
    "</kml>"

kOpenThreadNodeId

constexpr char cuttlefish::kOpenThreadNodeId[] = "openthread_node_id"

staticconstexpr

kOperatorNumeric

constexpr char cuttlefish::kOperatorNumeric[] = "operator_numeric"

staticconstexpr

kOpewnrtWanIpAddressName

constexpr auto cuttlefish::kOpewnrtWanIpAddressName = "wan_ipaddr"

constexpr

kOtherosEspImage

constexpr char cuttlefish::kOtherosEspImage[] = "otheros_esp_image"

staticconstexpr

kOverlays

constexpr char cuttlefish::kOverlays[] = "overlays"

staticconstexpr

kPadValue

constexpr uint8_t cuttlefish::kPadValue = 0xff

staticconstexpr

kPauseInBootloader

constexpr char cuttlefish::kPauseInBootloader[] = "pause_in_bootloader"

staticconstexpr

kPhoneInstanceTemplate

constexpr std::string_view cuttlefish::kPhoneInstanceTemplate

staticconstexpr

Initial value:

= R""""(
{
    "vm": {
        "memory_mb": 4096
    },
    "graphics":{
        "displays":[
            {
                "width": 720,
                "height": 1280,
                "dpi": 320
            }
        ]
    }
}
  )""""

kPicaUciPort

constexpr char cuttlefish::kPicaUciPort[] = "pica_uci_port"

staticconstexpr

kPreferredNetworkMode

constexpr char cuttlefish::kPreferredNetworkMode[] = "preferred_network_mode"

staticconstexpr

kProcDir

constexpr char cuttlefish::kProcDir[] = "/proc"

staticconstexpr

kQemuBinaryDir

constexpr char cuttlefish::kQemuBinaryDir[] = "qemu_binary_dir"

staticconstexpr

kQemuVncServerPort

constexpr char cuttlefish::kQemuVncServerPort[] = "qemu_vnc_server_port"

staticconstexpr

kRecordScreen

constexpr char cuttlefish::kRecordScreen[] = "record_screen"

staticconstexpr

kRefreshRateHz

constexpr char cuttlefish::kRefreshRateHz[] = "refresh_rate_hz"

staticconstexpr

kRepeatableFlags

std::unordered_set<std::string> cuttlefish::kRepeatableFlags

static

Initial value:

= {
    "custom_action_config", "custom_actions", "display", "touchpad", "media"}

kRequiresHostBluetoothConnector

constexpr char cuttlefish::kRequiresHostBluetoothConnector[]

staticconstexpr

Initial value:

=
    "enable_host_bluetooth_connector"

kRestartSubprocesses

constexpr char cuttlefish::kRestartSubprocesses[] = "restart_subprocesses"

staticconstexpr

kRilBroadcast

constexpr char cuttlefish::kRilBroadcast[] = "ril_broadcast"

staticconstexpr

kRilDns

constexpr char cuttlefish::kRilDns[] = "ril_dns"

staticconstexpr

kRilGateway

constexpr char cuttlefish::kRilGateway[] = "ril_gateway"

staticconstexpr

kRilIpaddr

constexpr char cuttlefish::kRilIpaddr[] = "ril_ipaddr"

staticconstexpr

kRilPrefixlen

constexpr char cuttlefish::kRilPrefixlen[] = "ril_prefixlen"

staticconstexpr

kRootcanalArgs

constexpr char cuttlefish::kRootcanalArgs[] = "rootcanal_args"

staticconstexpr

kRootcanalHciPort

constexpr char cuttlefish::kRootcanalHciPort[] = "rootcanal_hci_port"

staticconstexpr

kRootcanalLinkBlePort

constexpr char cuttlefish::kRootcanalLinkBlePort[] = "rootcanal_link_ble_port"

staticconstexpr

kRootcanalLinkPort

constexpr char cuttlefish::kRootcanalLinkPort[] = "rootcanal_link_port"

staticconstexpr

kRootcanalTestPort

constexpr char cuttlefish::kRootcanalTestPort[] = "rootcanal_test_port"

staticconstexpr

kRootDir

constexpr char cuttlefish::kRootDir[] = "root_dir"

staticconstexpr

kRsrpRange

constexpr auto cuttlefish::kRsrpRange = std::make_pair(-140, -44)

constexpr

kRssiRange

constexpr auto cuttlefish::kRssiRange = std::make_pair(4, 30)

constexpr

kRssiUnknownValue

constexpr int cuttlefish::kRssiUnknownValue = 99

constexpr

kRunAsDaemon

constexpr char cuttlefish::kRunAsDaemon[] = "run_as_daemon"

staticconstexpr

kRunModemSimulator

constexpr char cuttlefish::kRunModemSimulator[] = "enable_modem_simulator"

staticconstexpr

kRwxAllMode

constexpr mode_t cuttlefish::kRwxAllMode = S_IRWXU | S_IRWXG | S_IRWXO

staticconstexpr

kScreenChangedMessage

constexpr char cuttlefish::kScreenChangedMessage[] = "VIRTUAL_DEVICE_SCREEN_CHANGED"

inlineconstexpr

kSeccompPolicyDir

constexpr char cuttlefish::kSeccompPolicyDir[] = "seccomp_policy_dir"

staticconstexpr

kSectorSize

constexpr int cuttlefish::kSectorSize = 1 << kSectorSizeShift

inlineconstexpr

kSectorSizeShift

constexpr int cuttlefish::kSectorSizeShift = 9

inlineconstexpr

kSecureHals

constexpr char cuttlefish::kSecureHals[] = "secure_hals"

staticconstexpr

kSerialNumber

constexpr char cuttlefish::kSerialNumber[] = "serial_number"

staticconstexpr

kServerExecPath

constexpr char cuttlefish::kServerExecPath[] = "/proc/self/exe"

constexpr

kSessionId

constexpr char cuttlefish::kSessionId[] = "session_id"

staticconstexpr

kSetupWizardMode

constexpr char cuttlefish::kSetupWizardMode[] = "setupwizard_mode"

staticconstexpr

kSharedDirName

constexpr char cuttlefish::kSharedDirName[] = "shared"

inlineconstexpr

kSigServerAddress

constexpr char cuttlefish::kSigServerAddress[] = "webrtc_sig_server_addr"

staticconstexpr

kSigServerPort

constexpr char cuttlefish::kSigServerPort[] = "webrtc_sig_server_port"

staticconstexpr

kSimPinMaxRetryTimes

constexpr int cuttlefish::kSimPinMaxRetryTimes = 3

constexpr

kSimPukMaxRetryTimes

constexpr int cuttlefish::kSimPukMaxRetryTimes = 10

constexpr

kSimPukSize

constexpr int cuttlefish::kSimPukSize = 8

constexpr

kSlimInstanceTemplate

constexpr std::string_view cuttlefish::kSlimInstanceTemplate

staticconstexpr

Initial value:

= R""""(
{
    "vm": {
        "memory_mb": 2048,
        "use_sdcard" : false
    },
    "graphics":{
        "displays":[
            {
                "width": 720,
                "height": 1280,
                "dpi": 320
            }
        ]
    }
}
  )""""

kSmt

constexpr char cuttlefish::kSmt[] = "smt"

staticconstexpr

kSnapshotPath

constexpr char cuttlefish::kSnapshotPath[] = "snapshot_path"

staticconstexpr

kSnapshotPathField

constexpr const char cuttlefish::kSnapshotPathField[] = "snapshot_path"

inlineconstexpr

kSnrUnknownValue

constexpr int cuttlefish::kSnrUnknownValue = -1

constexpr

kSocketMode

constexpr int cuttlefish::kSocketMode = 0666

inlineconstexpr

kSRIAndMMSIndicator

const std::string cuttlefish::kSRIAndMMSIndicator = "24"

static

kStartCasimir

constexpr char cuttlefish::kStartCasimir[] = "start_casimir"

staticconstexpr

kStartNetsim

constexpr char cuttlefish::kStartNetsim[] = "start_netsim"

staticconstexpr

kStartPica

constexpr char cuttlefish::kStartPica[] = "start_pica"

staticconstexpr

kStartRootcanal

constexpr char cuttlefish::kStartRootcanal[] = "start_rootcanal"

staticconstexpr

kStartWmediumd

constexpr char cuttlefish::kStartWmediumd[] = "start_wmediumd"

staticconstexpr

kStartWmediumdInstance

constexpr char cuttlefish::kStartWmediumdInstance[] = "start_wmediumd_instance"

staticconstexpr

kStatusReportIndicator

const std::string cuttlefish::kStatusReportIndicator = "06"

static

kStracedExecutables

constexpr char cuttlefish::kStracedExecutables[] = "straced_host_executables"

staticconstexpr

kSummaryHelpText

constexpr char cuttlefish::kSummaryHelpText[]

constexpr

Initial value:

=
    R"(lists active devices with relevant information)"

kSuperImage

constexpr char cuttlefish::kSuperImage[] = "super_image"

staticconstexpr

kSystemTargetZip

constexpr char cuttlefish::kSystemTargetZip[] = "system_target_zip"

staticconstexpr

kTabletInstanceTemplate

constexpr std::string_view cuttlefish::kTabletInstanceTemplate

staticconstexpr

Initial value:

= R""""(
{
    "vm": {
        "memory_mb": 4096
    },
    "graphics":{
        "displays":[
            {
                "width": 2560,
                "height": 1800,
                "dpi": 320
            }
        ]
    }
}
  )""""

kTargetArch

constexpr char cuttlefish::kTargetArch[] = "target_arch"

staticconstexpr

kTargetDirectory

constexpr char cuttlefish::kTargetDirectory[] = "--target_directory=/tmp/fetch_test"

inlineconstexpr

kTi50

constexpr char cuttlefish::kTi50[] = "ti50"

staticconstexpr

kTombstoneReceiverPort

constexpr char cuttlefish::kTombstoneReceiverPort[] = "tombstone_receiver_port"

staticconstexpr

kTouchpadConfigs

constexpr char cuttlefish::kTouchpadConfigs[] = "touchpad_configs"

staticconstexpr

kTouchpadFlag

constexpr const char cuttlefish::kTouchpadFlag[] = "touchpad"

constexpr

kTouchpadHelp

constexpr const char cuttlefish::kTouchpadHelp[]

constexpr

Initial value:

=
    "Comma separated key=value pairs of touchpad properties. Supported "
    "properties:\n"
    " 'width': required, width of the touchpad in pixels\n"
    " 'height': required, height of the touchpad in pixels\n"
    ". Example usage: \n"
    "--touchpad=width=640,height=480\n"

kTouchpadPrefix

constexpr auto cuttlefish::kTouchpadPrefix = "touch_"

constexpr

kTouchscreenPrefix

constexpr auto cuttlefish::kTouchscreenPrefix = "display_"

constexpr

kTransmitterPath

constexpr char cuttlefish::kTransmitterPath[]

inlineconstexpr

Initial value:

=
    "/usr/lib/cuttlefish-metrics/bin/metrics_transmitter"

kTraverseEmptyDocText

char cuttlefish::kTraverseEmptyDocText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\"></kml>"

kTvInstanceTemplate

constexpr std::string_view cuttlefish::kTvInstanceTemplate

staticconstexpr

Initial value:

= R""""(
{
    "vm": {
        "memory_mb": 2048
    },
    "graphics":{
        "displays":[
            {
                "width": 1920,
                "height": 1080,
                "dpi": 213
            }
        ]
    }
}
  )""""

kUDHIAndSRIAndMMSIndicator

const std::string cuttlefish::kUDHIAndSRIAndMMSIndicator = "64"

static

kUniqueKey [1/2]

constexpr char cuttlefish::kUniqueKey[] = "JsonSerializable"

staticconstexpr

kUniqueKey [2/2]

constexpr char cuttlefish::kUniqueKey[] = "TpmKeyBlobMaker"

staticconstexpr

kUsageMessage

constexpr char cuttlefish::kUsageMessage[]

staticconstexpr

Initial value:

=
    "<flags>\n"
    "\n"
    "env_size - length in bytes of the resulting env image. Defaults to 4kb.\n"
    "input_path - path to input key value mapping as a text file\n"
    "output_path - path to write resulting environment image including CRC "
    "to\n"

kUseBridgedWifiTap

constexpr char cuttlefish::kUseBridgedWifiTap[] = "use_bridged_wifi_tap"

staticconstexpr

kUseCvdalloc

constexpr char cuttlefish::kUseCvdalloc[] = "use_cvdalloc"

staticconstexpr

kUserdataFormat

constexpr char cuttlefish::kUserdataFormat[] = "userdata_format"

staticconstexpr

kUseSdcard

constexpr char cuttlefish::kUseSdcard[] = "use_sdcard"

staticconstexpr

kUuid

constexpr char cuttlefish::kUuid[] = "uuid"

staticconstexpr

kValidComplexText

char cuttlefish::kValidComplexText[]

kValidDocumentText

char cuttlefish::kValidDocumentText[]

kValidkmlText

char cuttlefish::kValidkmlText[]

Initial value:

=
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<kml xmlns=\"http://earth.google.com/kml/2.x\">"
    "<Placemark>"
    "<name>Simple placemark</name>"
    "<description>Attached to the ground.</description>"
    "<Point>"
    "<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>"
    "</Point>"
    "</Placemark>"
    "</kml>"

kValidLocationText

char cuttlefish::kValidLocationText[]

Initial value:

=
    "<?xml version=\"1.0\"?>"
    "<gpx>"
    "<wpt lon=\"9.81\" lat=\"3.1415\">"
    "<ele>6.02</ele>"
    "<name>Name</name>"
    "<desc>Desc</desc>"
    "</wpt>"
    "</gpx>"

kValidText

char cuttlefish::kValidText[]

kVbmetaImage

constexpr char cuttlefish::kVbmetaImage[] = "vbmeta_image"

staticconstexpr

kVbmetaSystemDlkmImage

constexpr char cuttlefish::kVbmetaSystemDlkmImage[] = "vbmeta_system_dlkm_image"

staticconstexpr

kVbmetaSystemImage

constexpr char cuttlefish::kVbmetaSystemImage[] = "vbmeta_system_image"

staticconstexpr

kVbmetaVendorDlkmImage

constexpr char cuttlefish::kVbmetaVendorDlkmImage[] = "vbmeta_vendor_dlkm_image"

staticconstexpr

kVcpuInfo

constexpr char cuttlefish::kVcpuInfo[] = "vcpu_config_path"

staticconstexpr

kVendorBootImage

constexpr char cuttlefish::kVendorBootImage[] = "vendor_boot_image"

staticconstexpr

kVhalProxyServerPort

constexpr char cuttlefish::kVhalProxyServerPort[] = "vhal_proxy_server_port"

staticconstexpr

kVhostNet

constexpr char cuttlefish::kVhostNet[] = "vhost_net"

staticconstexpr

kVhostUserBlock

constexpr char cuttlefish::kVhostUserBlock[] = "vhost_user_block"

staticconstexpr

kVhostUserMac80211Hwsim

constexpr char cuttlefish::kVhostUserMac80211Hwsim[] = "vhost_user_mac80211_hwsim"

staticconstexpr

kVhostUserVsock

constexpr char cuttlefish::kVhostUserVsock[] = "vhost_user_vsock"

staticconstexpr

kVhostUserVsockModeAuto

constexpr char cuttlefish::kVhostUserVsockModeAuto[] = "auto"

inlineconstexpr

kVhostUserVsockModeFalse

constexpr char cuttlefish::kVhostUserVsockModeFalse[] = "false"

inlineconstexpr

kVhostUserVsockModeTrue

constexpr char cuttlefish::kVhostUserVsockModeTrue[] = "true"

inlineconstexpr

kVhostVsockPath

constexpr char cuttlefish::kVhostVsockPath[] = "vhost_vsock_path"

staticconstexpr

kVirtioMac80211Hwsim

constexpr char cuttlefish::kVirtioMac80211Hwsim[] = "virtio_mac80211_hwsim"

staticconstexpr

kVirtualDiskPaths

constexpr char cuttlefish::kVirtualDiskPaths[] = "virtual_disk_paths"

staticconstexpr

kVmManager

constexpr char cuttlefish::kVmManager[] = "vm_manager"

staticconstexpr

kVsockGuestCid

constexpr char cuttlefish::kVsockGuestCid[] = "vsock_guest_cid"

staticconstexpr

kVsockGuestGroup

constexpr char cuttlefish::kVsockGuestGroup[] = "vsock_guest_group"

staticconstexpr

kVsocUserPrefix

constexpr char cuttlefish::kVsocUserPrefix[] = "vsoc-"

inlineconstexpr

kVulkanDriver

constexpr char cuttlefish::kVulkanDriver[] = "guest_vulkan_driver"

staticconstexpr

kVvmtruststorePath

constexpr char cuttlefish::kVvmtruststorePath[] = "vvmtruststore_path"

staticconstexpr

kWearableInstanceTemplate

constexpr std::string_view cuttlefish::kWearableInstanceTemplate

staticconstexpr

Initial value:

= R""""(
{
    "vm": {
        "memory_mb": 1536,
        "use_sdcard" : false
    },
    "graphics":{
        "displays":[
            {
                "width": 450,
                "height": 450,
                "dpi": 320
            }
        ]
    }
}
  )""""

kWebRTCAssetsDir

constexpr char cuttlefish::kWebRTCAssetsDir[] = "webrtc_assets_dir"

staticconstexpr

kWebrtcDeviceId

constexpr char cuttlefish::kWebrtcDeviceId[] = "webrtc_device_id"

staticconstexpr

kWebrtcTcpPortRange

constexpr char cuttlefish::kWebrtcTcpPortRange[] = "webrtc_tcp_port_range"

staticconstexpr

kWebrtcUdpPortRange

constexpr char cuttlefish::kWebrtcUdpPortRange[] = "webrtc_udp_port_range"

staticconstexpr

kWhenDumpedHelp

constexpr char cuttlefish::kWhenDumpedHelp[] = "restart when the process crashed"

staticconstexpr

kWhenExitedWithCodeHelp

constexpr char cuttlefish::kWhenExitedWithCodeHelp[]

staticconstexpr

Initial value:

=
    "restart when the process exited with a specific code"

kWhenExitedWithFailureHelp

constexpr char cuttlefish::kWhenExitedWithFailureHelp[]

staticconstexpr

Initial value:

=
    "restart when the process exited with a code !=0"

kWhenKilledHelp

constexpr char cuttlefish::kWhenKilledHelp[] = "restart when the process was killed"

staticconstexpr

kWifiBridgeName

constexpr char cuttlefish::kWifiBridgeName[] = "wifi_bridge_name"

staticconstexpr

kWifiConnectedMessage

constexpr char cuttlefish::kWifiConnectedMessage[]

inlineconstexpr

Initial value:

=
    "VIRTUAL_DEVICE_NETWORK_WIFI_CONNECTED"

kWifiMac

constexpr char cuttlefish::kWifiMac[] = "wifi_mac"

staticconstexpr

kWifiMacPrefix

constexpr char cuttlefish::kWifiMacPrefix[] = "wifi_mac_prefix"

staticconstexpr

kWifiTapName

constexpr char cuttlefish::kWifiTapName[] = "wifi_tap_name"

staticconstexpr

kWirelessIp

constexpr char cuttlefish::kWirelessIp[] = "192.168.96"

inlineconstexpr

kWithoutServiceCenterAddress

const std::string cuttlefish::kWithoutServiceCenterAddress = "00"

static

kWmediumdApiServerSocket

constexpr char cuttlefish::kWmediumdApiServerSocket[] = "wmediumd_api_server_socket"

staticconstexpr

kWmediumdConfig

constexpr char cuttlefish::kWmediumdConfig[] = "wmediumd_config"

staticconstexpr

kWmediumdMacPrefix

constexpr char cuttlefish::kWmediumdMacPrefix[] = "wmediumd_mac_prefix"

staticconstexpr

kXRes

constexpr char cuttlefish::kXRes[] = "x_res"

staticconstexpr

kXtermUseAlternateScreen

constexpr std::string_view cuttlefish::kXtermUseAlternateScreen = "\033[?1049h"

inlineconstexpr

kXtermUseMainScreen

constexpr std::string_view cuttlefish::kXtermUseMainScreen = "\033[?1049l"

inlineconstexpr

kYRes

constexpr char cuttlefish::kYRes[] = "y_res"

staticconstexpr

kZedbootDestPath

constexpr char cuttlefish::kZedbootDestPath[] = "/zedboot.zbi"

staticconstexpr

last_tombstone_name

std::string cuttlefish::last_tombstone_name = ""

static

MarshalFn

template<typename T >

int cuttlefish::MarshalFn = 0

MarshalFn< TPM2B_PRIVATE >

template<>

auto cuttlefish::MarshalFn< TPM2B_PRIVATE > = Tss2_MU_TPM2B_PRIVATE_Marshal

MarshalFn< TPM2B_PUBLIC >

template<>

auto cuttlefish::MarshalFn< TPM2B_PUBLIC > = Tss2_MU_TPM2B_PUBLIC_Marshal

MAX_STIR_RANDOM_BUFFER_SIZE

int cuttlefish::MAX_STIR_RANDOM_BUFFER_SIZE = 128

static

MF_SIM

const std::string cuttlefish::MF_SIM = "3F00"

static

num_tombstones_in_last_second

uint64_t cuttlefish::num_tombstones_in_last_second = 0

static

PARTITION_SIZE_SHIFT

constexpr int cuttlefish::PARTITION_SIZE_SHIFT = 12

constexpr

pipe_message

char cuttlefish::pipe_message[] = "Testing the pipe"

TIMEOUT_SEC

constexpr size_t cuttlefish::TIMEOUT_SEC = 3

staticconstexpr

UnmarshalFn

template<typename T >

int cuttlefish::UnmarshalFn = 0

UnmarshalFn< TPM2B_PRIVATE >

template<>

auto cuttlefish::UnmarshalFn< TPM2B_PRIVATE > = Tss2_MU_TPM2B_PRIVATE_Unmarshal

UnmarshalFn< TPM2B_PUBLIC >

template<>

auto cuttlefish::UnmarshalFn< TPM2B_PUBLIC > = Tss2_MU_TPM2B_PUBLIC_Unmarshal

VIOS_VERSION

constexpr uint32_t cuttlefish::VIOS_VERSION = 3

inlineconstexpr

VIRTIO_SND_CHMAP_MAX_SIZE

constexpr uint8_t cuttlefish::VIRTIO_SND_CHMAP_MAX_SIZE = 18

constexpr