cuttlefish Namespace Reference

Namespaces
namespace	acloud
namespace	acloud_impl
namespace	anonymous_namespace{acloud_command.cpp}
namespace	anonymous_namespace{adb_connection_maintainer.cpp}
namespace	anonymous_namespace{android_build_api.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{ap_composite_disk.cc}
namespace	anonymous_namespace{archive.cpp}
namespace	anonymous_namespace{assemble_cvd.cc}
namespace	anonymous_namespace{audio_handler.cpp}
namespace	anonymous_namespace{avb.cpp}
namespace	anonymous_namespace{boot_config.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_flags.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_flags.cc}
namespace	anonymous_namespace{cf_metrics_configs.cpp}
namespace	anonymous_namespace{cf_security_configs.cpp}
namespace	anonymous_namespace{clean.cc}
namespace	anonymous_namespace{clear.cpp}
namespace	anonymous_namespace{command_sequence.cpp}
namespace	anonymous_namespace{config.cpp}
namespace	anonymous_namespace{config_flag.cpp}
namespace	anonymous_namespace{control_env_proxy_server.cpp}
namespace	anonymous_namespace{converter.cpp}
namespace	anonymous_namespace{crc.cpp}
namespace	anonymous_namespace{create.cpp}
namespace	anonymous_namespace{create_converter_parser.cpp}
namespace	anonymous_namespace{credential_source.cc}
namespace	anonymous_namespace{crosvm_builder.cpp}
namespace	anonymous_namespace{crosvm_cpu.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.cpp}
namespace	anonymous_namespace{cvd_metrics_api.cpp}
namespace	anonymous_namespace{cvd_video_frame_buffer.cpp}
namespace	anonymous_namespace{cvdalloc.cpp}
namespace	anonymous_namespace{data.cpp}
namespace	anonymous_namespace{data_image.cpp}
namespace	anonymous_namespace{de_android_sparse.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{downloaders.cc}
namespace	anonymous_namespace{env.cpp}
namespace	anonymous_namespace{events.cc}
namespace	anonymous_namespace{fetch.cpp}
namespace	anonymous_namespace{fetch_config_parser.cpp}
namespace	anonymous_namespace{fetch_cvd.cc}
namespace	anonymous_namespace{fetch_cvd_parser.cc}
namespace	anonymous_namespace{fetch_tracer.cpp}
namespace	anonymous_namespace{fetcher_config.cpp}
namespace	anonymous_namespace{files.cpp}
namespace	anonymous_namespace{flag_forwarder.cc}
namespace	anonymous_namespace{flag_parser.cpp}
namespace	anonymous_namespace{flags.cc}
namespace	anonymous_namespace{flags.cpp}
namespace	anonymous_namespace{flags_collector.cpp}
namespace	anonymous_namespace{generate_persistent_vbmeta.cpp}
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{help.cpp}
namespace	anonymous_namespace{help_test.cpp}
namespace	anonymous_namespace{hex.cpp}
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{initialize_instance_composite_disk.cc}
namespace	anonymous_namespace{instance_database.cpp}
namespace	anonymous_namespace{instance_group_record.cpp}
namespace	anonymous_namespace{instance_manager.cpp}
namespace	anonymous_namespace{instance_record.cpp}
namespace	anonymous_namespace{interrupt_listener.cpp}
namespace	anonymous_namespace{kernel_args.cpp}
namespace	anonymous_namespace{kernel_log_monitor.cpp}
namespace	anonymous_namespace{kernel_ramdisk_repacker.cpp}
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{lint.cpp}
namespace	anonymous_namespace{load_configs.cpp}
namespace	anonymous_namespace{load_configs_parser.cpp}
namespace	anonymous_namespace{log_tee_creator.cpp}
namespace	anonymous_namespace{login.cpp}
namespace	anonymous_namespace{main.cc}
namespace	anonymous_namespace{main.cpp}
namespace	anonymous_namespace{mcu.cpp}
namespace	anonymous_namespace{metrics.cc}
namespace	anonymous_namespace{metrics_launcher.cpp}
namespace	anonymous_namespace{metrics_notice.cpp}
namespace	anonymous_namespace{misc_info.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{noop.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{parse.cc}
namespace	anonymous_namespace{pdu_format_builder.cc}
namespace	anonymous_namespace{pdu_format_builder_test.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{process_monitor.cc}
namespace	anonymous_namespace{qcow2.cc}
namespace	anonymous_namespace{record_cvd.cc}
namespace	anonymous_namespace{remote_zip.cc}
namespace	anonymous_namespace{remote_zip_test.cc}
namespace	anonymous_namespace{remove.cpp}
namespace	anonymous_namespace{request_context.cpp}
namespace	anonymous_namespace{reset.cpp}
namespace	anonymous_namespace{reset_client_utils.cpp}
namespace	anonymous_namespace{restart.cpp}
namespace	anonymous_namespace{restart_cvd.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{run_server.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{serialize_disjoint_range_set_test.cc}
namespace	anonymous_namespace{server.cpp}
namespace	anonymous_namespace{shared_buf.cc}
namespace	anonymous_namespace{shared_fd.cpp}
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{subprocess.cpp}
namespace	anonymous_namespace{subprocess_managed_stdio.cc}
namespace	anonymous_namespace{substitute.cc}
namespace	anonymous_namespace{super_image_mixer.cc}
namespace	anonymous_namespace{suspend_resume_handler.cpp}
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{try_acloud.cpp}
namespace	anonymous_namespace{users.cpp}
namespace	anonymous_namespace{util.cc}
namespace	anonymous_namespace{vendor_dlkm_utils.cc}
namespace	anonymous_namespace{version.cpp}
namespace	anonymous_namespace{vhost_device_vsock.cpp}
namespace	anonymous_namespace{vhost_input_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	anonymous_namespace{zip_cc.cc}
namespace	anonymous_namespace{zip_copy_test.cc}
namespace	confui
namespace	contains_internal_impl
namespace	cvd_common
namespace	cvd_impl
namespace	cvdalloc
namespace	cvdsnapshot
namespace	http_client
namespace	internal
namespace	metrics
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	vm_manager
namespace	webrtc_signaling
namespace	webrtc_streaming

Classes
class	AcloudConfig
class	AcloudMixSuperImageCommand
class	AcloudTranslatorCommand
struct	AcloudTranslatorOptOut
class	AdbConfig
class	AdbConfigFlag
class	AdbConfigFragment
class	AndroidBuildApi
class	AndroidBuildUrl
class	AndroidEfiLoaderEspBuilder
class	AndroidEfiLoaderFlag
class	AndroidSparseImage
class	ApBootloaderEnvPartition
class	ApCompositeDisk
class	ApPersistentVbmeta
struct	AttestationIds
class	AudioClientConnection
class	AudioCommand
class	AudioHandler
class	AudioServer
class	AudioServerExecutor
class	Avb
class	BlankDataImageMbFlag
class	BootConfigPartition
class	BootImageFlag
class	BootloaderEnvPartition
class	BootloaderFlag
class	BuildApi
struct	BuildApiFlags
struct	Builds
struct	BuildStrings
class	CachingBuildApi
class	CallService
class	CameraController
class	CasDownloader
struct	CasDownloaderFlags
class	CasDownloaderTests
struct	CasIdentifier
class	CasimirController
class	CfConnectionObserverFactory
class	CfOperatorObserver
struct	ChainPartition
class	ChannelMonitor
class	ChmapInfoCommand
struct	ChromeOsBuildArtifacts
struct	ChromeOsBuilder
class	ChromeOsStateImage
class	Clearcut
class	Client
class	ClientFilesServer
class	ClientId
class	ClientSocket
class	CmdResult
class	CmdRunner
class	Command
class	CommandHandler
class	CommandParser
class	CommandRequest
class	CommandRequestBuilder
class	CommandSequenceExecutor
class	CommandSource
class	CompareHmacSharingParams
class	CompositeDiskImage
class	CompositeSerializable
class	CompositionManager
class	ConfigFlag
class	ConfigFragment
class	ConfUiSignerImpl
class	ConfUiSignRequester
class	ConfUiSignSender
class	ConfUiSignServer
class	ConnectionObserverImpl
class	ConsoleForwarder
struct	ConstructCommandParam
struct	ConstructNonHelpForm
struct	ControlMessage
struct	ControlPanelButton
struct	ConvertedAcloudCreateCommand
class	CpusFlag
struct	CredentialFlags
class	CredentialSource
class	CrosvmBuilder
class	CurlGlobalInit
class	CustomActionConfigProvider
struct	CustomActionInstanceID
struct	CustomActionServerConfig
struct	CustomDeviceStateActionConfig
struct	CustomShellActionConfig
class	CuttlefishConfig
class	Cvd
class	CvdClient
class	CvdCmdlistHandler
class	CvdCommandHandler
class	CvdCreateCommandHandler
struct	CvdFile
struct	CvdFlags
class	CvdFleetCommandHandler
class	CvdHelpHandler
class	CvdIdAllocatorTest
class	CvdMetrics
class	CvdStartCommandHandler
class	CvdStatusCommandHandler
class	CvdVideoFrameBuffer
class	DataService
class	DataViewer
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	EmulateAbsolutePathBase
class	EmulateAbsolutePathWithHome
class	EmulateAbsolutePathWithPwd
class	EncryptedSerializable
class	Epoll
struct	EpollEvent
class	EspBuilder
struct	EsysDeleter
class	EsysLock
class	EthernetIface
struct	EthernetNetworkConfig
class	EventBuffer
class	EventSinkImpl
class	FactoryResetProtectedImage
class	FakeHttpClient
class	FastbootConfig
class	FastbootConfigFlag
class	FastbootConfigFragment
class	Feature
class	FetchCvdTests
class	FetcherConfig
struct	FetchFlags
struct	FetchResult
class	FetchTracer
class	FileInstance
struct	FileSizes
class	FilesTests
class	Flag
struct	FlagAlias
class	FlagConsumesArbitraryTest
class	FlagFeature
class	FlagForwarder
class	FlagInfo
struct	FlagMatch
class	FuchsiaEspBuilder
class	GamepadDevice
class	GatekeeperResponder
class	GatekeeperStorage
struct	GatewayConfig
struct	GenericCommandImpl
struct	GenericCommandImpl< Fn, R(*)(Args...)>
class	GenericCommandSource
class	GenericReturningSetupFeature
struct	GenericSetupImpl
struct	GenericSetupImpl< Fn, Result< R >(*)(Args...)>
class	GnssClient
struct	GroupProcInfo
class	GrpcSocketCreator
struct	GuestConfig
class	HmacSerializable
class	HostModeCtrl
struct	HostToolsTarget
class	HostToolTarget
class	HttpClient
struct	HttpHeader
struct	HttpRequest
struct	HttpResponse
struct	HttpVoidResponse
struct	IfaceConfig
struct	IfaceData
struct	ImagePartition
class	InfoCommand
class	InitramfsPathFlag
class	InProcessTpm
class	InputConnection
class	InputConnectionsProvider
class	InputConnector
class	InputConnectorBuilder
class	InputConnectorImpl
class	InputDevice
struct	InputDevices
struct	InputOutput
struct	InputPathForm
class	InstanceCompositeDisk
class	InstanceDatabase
class	InstanceLockFile
class	InstanceLockFileManager
class	InstanceManager
class	InstanceNumsCalculator
class	InterruptibleTerminal
class	InterruptListenerHandle
struct	IoStatusMsg
struct	IoTransferMsg
struct	is_movable
class	JackInfoCommand
class	JsonRequestReader
	Provides a wrapper around libjson's Reader to additionally log errors. More...
class	JsonSerializable
struct	KernelLogEventsHandler
class	KernelLogPipeConsumer
class	KernelLogPipeProvider
class	KernelPathFlag
class	KeyboardDevice
class	KeymasterResponder
class	LateInjected
struct	LauncherActionInfo
class	LazilyLoadedFile
class	LazilyLoadedFileReadCallback
class	LintCommandHandler
class	LinuxEspBuilder
struct	LoadDirectories
struct	LoadFlags
class	LocalInstance
class	LocalInstanceGroup
class	LogTeeCreator
class	LuciBuildApi
class	McuConfigPathFlag
class	MetadataImage
class	MetricsHostReceiver
class	MetricsReceiver
class	MiscImage
class	MiscService
class	MobileIface
class	ModemService
class	ModemSimulator
struct	MonitorCommand
struct	MonitorEntry
class	MouseDevice
struct	msg_buffer
class	Multiplexer
struct	MultitouchSlot
class	NetworkService
class	NvramConfig
struct	Oauth2ConsentRequest
class	OneEachTest
class	OperatorControlConn
struct	Overload
struct	Override
struct	Parsed
class	ParseGflags
class	ParseGflagsImpl
struct	Parser
class	PDUFormatBuilder
class	PDUParser
class	PersistentVbmeta
struct	PollSharedFd
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	RequestContext
struct	RequestHeader
	Defines the format for allocd Request messages. More...
struct	ResourceManager
class	ReturningSetupFeature
class	RotaryDevice
class	RxBuffer
class	ScopedMMap
class	ScopedTeeLogger
class	ScreenConnector
class	ScreenConnectorCtrl
struct	ScreenConnectorFrameInfo
struct	ScreenConnectorFrameRenderer
class	ScreenConnectorInputMultiplexer
class	ScreenConnectorQueue
class	ScreenshotHandler
class	SeekableZipSource
class	SeekableZipSourceCallback
class	SeekingZipSourceReader
class	Semaphore
struct	SensorsSocketPair
struct	Separated
class	ServerLoop
class	ServerSocket
class	Session
class	SetupFeature
struct	SeverityTarget
class	SharedFD
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	StaticResource
class	StatusCheckCommandSource
class	StkService
struct	StreamControlCommand
class	StreamInfoCommand
struct	StreamSetParamsCommand
class	Subprocess
class	SubprocessFlag
class	SubprocessOptions
class	SubprocessWaiter
class	SuperImageFlag
class	SupService
class	SwitchesDevice
class	SystemImageDirFlag
class	SysVMessageQueue
struct	TargetDirectories
class	TeeLogger
class	TerminalColors
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
class	TryAcloudCommand
struct	TypeAndId
class	UniqueResourceAllocator
class	UnixMessageSocket
struct	UnixSocketMessage
struct	VbmetaArgs
struct	VectorFlags
class	VendorBootImageFlag
struct	VersionIdentifiers
class	VideoFrameBuffer
struct	VioSConfig
struct	virtio_snd_chmap_info
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	ZipSourceReader
class	ZipSourceWriter
struct	ZipStat

Typedefs
template<typename T >
using	Result = android::base::expected< T, StackTraceError >
using	SubprocessStopper = std::function< StopperResult(Subprocess *)>
using	Message = std::vector< std::uint8_t >
using	MiscInfo = std::map< std::string, 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	OnConsumedCb = std::function< void(AudioStatus, uint32_t, uint32_t)>
using	TxBuffer = ShmBuffer
template<auto Fn>
using	AutoSetup = GenericSetupImpl< Fn, decltype(Fn)>
typedef struct cuttlefish::msg_buffer	msg_buffer
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 >

Enumerations
enum class	RequestType : uint16_t {   Invalid = 0 , ID , CreateInterface , DestroyInterface ,   StopSession , Shutdown , Invalid = 0 , ID ,   CreateInterface , DestroyInterface , StopSession , Shutdown }
	Defines operations supported by allocd. More...
enum class	IfaceType : uint16_t {   Invalid = 0 , mtap , wtap , wifiap ,   etap , wbr , ebr , Invalid = 0 ,   mtap , wtap , wifiap , etap ,   wbr , ebr }
	Defines interface types supported by allocd. More...
enum class	RequestStatus : uint16_t {   Invalid = 0 , Pending , Success , Failure ,   Invalid = 0 , Pending , Success , Failure }
enum class	ResourceType { Invalid = 0 , MobileIface , EthernetIface , EthernetBridge }
enum class	Arch {   Arm , Arm64 , RiscV64 , X86 ,   X86_64 }
enum class	DeviceType {   Unknown = 0 , Phone , Wear , Auto ,   Foldable , Tv , Minidroid , Go }
enum class	FlagAliasMode { kFlagPrefix , kFlagExact , kFlagConsumesFollowing , kFlagConsumesArbitrary }
enum class	StopperResult { kStopFailure , kStopCrash , kStopSuccess }
enum class	MetadataLevel { FULL , ONLY_MESSAGE , TAG_AND_MESSAGE }
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	SnapshotSocketMessage : uint8_t { kSuspend = 1 , kSuspendAck = 2 , kResume = 3 }
enum class	SnapshotCmd : int { kUnknown = 0 , kSuspend = 1 , kResume = 2 , kSnapshotTake = 3 }
enum class	RequestType : uint16_t {   Invalid = 0 , ID , CreateInterface , DestroyInterface ,   StopSession , Shutdown , Invalid = 0 , ID ,   CreateInterface , DestroyInterface , StopSession , Shutdown }
	Defines operations supported by allocd. More...
enum class	IfaceType : uint16_t {   Invalid = 0 , mtap , wtap , wifiap ,   etap , wbr , ebr , Invalid = 0 ,   mtap , wtap , wifiap , etap ,   wbr , ebr }
	Defines interface types supported by allocd. More...
enum class	RequestStatus : uint16_t {   Invalid = 0 , Pending , Success , Failure ,   Invalid = 0 , Pending , Success , Failure }
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 }
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	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	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 }
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 }
enum class	VmmMode { kUnknown , kCrosvm , kGem5 , kQemu }
enum class	GptPartitionType { kLinuxFilesystem = 0 , kEfiSystemPartition }
enum	MetricsExitCodes : int { kSuccess = 0 , kMetricsError =1 , kInvalidHostConfiguration = 2 }
enum class	HttpMethod { kGet , kPost , kDelete , kHead }
enum class	ZipCompression {   kDefault , kStore , kBzip2 , kDeflate ,   kXz , kZstd }

Functions
int	RunExternalCommand (const std::string &command)
bool	AddTapIface (const std::string &name)
bool	ShutdownIface (const std::string &name)
bool	BringUpIface (const std::string &name)
bool	CreateEthernetIface (const std::string &name, const std::string &bridge_name, bool has_ipv4_bridge, bool has_ipv6_bridge, bool use_ebtables_legacy)
std::string	MobileGatewayName (const std::string &ipaddr, uint16_t id)
std::string	MobileNetworkName (const std::string &ipaddr, const std::string &netmask, uint16_t id)
bool	CreateMobileIface (const std::string &name, uint16_t id, const std::string &ipaddr)
bool	DestroyMobileIface (const std::string &name, uint16_t id, const std::string &ipaddr)
bool	AddGateway (const std::string &name, const std::string &gateway, const std::string &netmask)
bool	DestroyGateway (const std::string &name, const std::string &gateway, const std::string &netmask)
bool	DestroyEthernetIface (const std::string &name, bool has_ipv4_bridge, bool has_ipv6_bridge, bool use_ebtables_legacy)
void	CleanupEthernetIface (const std::string &name, const EthernetNetworkConfig &config)
bool	CreateEbtables (const std::string &name, bool use_ipv4, bool use_ebtables_legacy)
bool	DestroyEbtables (const std::string &name, bool use_ipv4, bool use_ebtables_legacy)
bool	EbtablesBroute (const std::string &name, bool use_ipv4, bool add, bool use_ebtables_legacy)
bool	EbtablesFilter (const std::string &name, bool use_ipv4, bool add, bool use_ebtables_legacy)
bool	LinkTapToBridge (const std::string &tap_name, const std::string &bridge_name)
bool	CreateTap (const std::string &name)
bool	DeleteIface (const std::string &name)
bool	DestroyIface (const std::string &name)
std::optional< std::string >	GetUserName (uid_t uid)
bool	CreateBridge (const std::string &name)
bool	DestroyBridge (const std::string &name)
bool	SetupBridgeGateway (const std::string &bridge_name, const std::string &ipaddr)
void	CleanupBridgeGateway (const std::string &name, const std::string &ipaddr, const GatewayConfig &config)
bool	StartDnsmasq (const std::string &bridge_name, const std::string &gateway, const std::string &dhcp_range)
bool	StopDnsmasq (const std::string &name)
bool	IptableConfig (const std::string &network, bool add)
bool	CreateEthernetBridgeIface (const std::string &name, const std::string &ipaddr)
bool	DestroyEthernetBridgeIface (const std::string &name, const std::string &ipaddr)
uid_t	GetUserIDFromSock (SharedFD client_socket)
bool	SendJsonMsg (SharedFD client_socket, const Json::Value &resp)
std::optional< Json::Value >	RecvJsonMsg (SharedFD client_socket)
std::string	ReqTyToStr (RequestType req_ty)
RequestType	StrToReqTy (const std::string &req)
RequestStatus	StrToStatus (const std::string &st)
std::string	StatusToStr (RequestStatus st)
std::string	IfaceTyToStr (IfaceType iface)
IfaceType	StrToIfaceTy (const std::string &iface)
template<typename T >
constexpr std::underlying_type_t< T >	Enum2Base (T t)
ssize_t	WriteAll (SharedFD fd, const char *buf, size_t size)
ssize_t	ReadExact (SharedFD fd, char *buf, size_t size)
ssize_t	ReadAll (SharedFD fd, std::string *buf)
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)
std::string	RecvAll (SharedFD sock, const size_t count)
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)
static void	MakeAddress (const char *name, bool abstract, struct sockaddr_un *dest, socklen_t *len)
	TEST (SendFD, Basic)
Result< std::map< std::string, std::string > >	ParseKeyEqualsValue (const std::string &contents)
std::string	SerializeKeyEqualsValue (const std::map< std::string, std::string > &key_equals_value)
Result< void >	WriteKeyEqualsValue (const std::map< std::string, std::string > &key_equals_value, const std::string &path)
const std::string &	HostArchStr ()
Arch	HostArch ()
bool	IsHostCompatible (Arch arch)
std::ostream &	operator<< (std::ostream &out, Arch arch)
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)
bool	EncodeBase64 (const void *data, std::size_t size, std::string *out)
bool	DecodeBase64 (const std::string &data, std::vector< std::uint8_t > *buffer)
	TEST (Base64Test, EncodeMult3)
	TEST (Base64Test, EncodeNonMult3)
	TEST (Base64Test, DecodeMult3)
	TEST (Base64Test, DecodeNonMult3)
	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)
static bool	IsRunningInDocker ()
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)
Result< std::size_t >	GetDiskUsageBytes (const std::string &path)
Result< std::size_t >	GetDiskUsageGigabytes (const std::string &path)
std::optional< std::string >	StringFromEnv (const std::string &varname)
std::string	StringFromEnv (const std::string &varname, const std::string &defval)
bool	FileExists (const std::string &path, bool follow_symlinks)
Result< dev_t >	FileDeviceId (const std::string &path)
Result< bool >	CanHardLink (const std::string &source, const std::string &destination)
Result< ino_t >	FileInodeNumber (const std::string &path)
Result< bool >	AreHardLinked (const std::string &source, const std::string &destination)
Result< std::string >	CreateHardLink (const std::string &target, const std::string &hardlink, const bool overwrite_existing)
Result< void >	CreateSymLink (const std::string &target, const std::string &link, const bool overwrite_existing)
bool	FileHasContent (const std::string &path)
Result< void >	HardLinkDirecoryContentsRecursively (const std::string &source, const std::string &destination)
Result< void >	MoveDirectoryContents (const std::string &source, const std::string &destination)
Result< std::vector< std::string > >	DirectoryContents (const std::string &path)
Result< std::vector< std::string > >	DirectoryContentsPaths (const std::string &path)
bool	DirectoryExists (const std::string &path, bool follow_symlinks)
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)
bool	IsDirectoryEmpty (const std::string &path)
Result< void >	RecursivelyRemoveDirectory (const std::string &path)
bool	Copy (const std::string &from, const std::string &to)
std::string	AbsolutePath (const std::string &path)
off_t	FileSize (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)
bool	RemoveFile (const std::string &file)
std::string	ReadFile (const std::string &file)
Result< std::string >	ReadFileContents (const std::string &filepath)
std::string	CurrentDirectory ()
FileSizes	SparseFileSizes (const std::string &path)
bool	FileIsSocket (const std::string &path)
std::string	FindImage (const std::string &search_path, const std::vector< std::string > &pattern)
Result< std::string >	FindFile (const std::string &path, const std::string &target_name)
Result< void >	WalkDirectory (const std::string &dir, const std::function< bool(const std::string &)> &callback)
Result< std::string >	EmulateAbsolutePath (const InputPathForm &path_info)
Result< bool >	CanRename (const std::string &source, const std::string &destination)
bool	IsDirectory (const std::string &path)
void	CreateTempFileWithText (const std::string &filepath, const std::string &text)
	TEST_F (FilesTests, HardLinkRecursivelyFailsIfSourceIsNotADirectory)
	TEST_F (FilesTests, HardLinkRecursively)
	TEST_F (FilesTests, MoveDirectoryContentsFailsIfSourceIsNotADirectory)
	TEST_F (FilesTests, MoveDirectoryContents)
	TEST_P (EmulateAbsolutePathBase, NoHomeNoPwd)
	INSTANTIATE_TEST_SUITE_P (CommonUtilsTest, EmulateAbsolutePathBase, testing::Values(InputOutput{.path_to_convert_="/",.expected_="/"}, InputOutput{.path_to_convert_="",.expected_=""}, InputOutput{.path_to_convert_="/a/b/c/",.expected_="/a/b/c"}, InputOutput{.path_to_convert_="/a",.expected_="/a"}))
	TEST_P (EmulateAbsolutePathWithPwd, NoHomeYesPwd)
	INSTANTIATE_TEST_SUITE_P (CommonUtilsTest, EmulateAbsolutePathWithPwd, testing::Values(InputOutput{.path_to_convert_="",.working_dir_="/x/y/z",.expected_=""}, InputOutput{.path_to_convert_="a",.working_dir_="/x/y/z",.expected_="/x/y/z/a"}, InputOutput{.path_to_convert_=".",.working_dir_="/x/y/z",.expected_="/x/y/z"}, InputOutput{.path_to_convert_="..",.working_dir_="/x/y/z",.expected_="/x/y"}, InputOutput{.path_to_convert_="./k/../../t/./q",.working_dir_="/x/y/z",.expected_="/x/y/t/q"}))
	TEST_P (EmulateAbsolutePathWithHome, YesHomeNoPwd)
	INSTANTIATE_TEST_SUITE_P (CommonUtilsTest, EmulateAbsolutePathWithHome, testing::Values(InputOutput{.path_to_convert_="~",.home_dir_="/x/y/z",.expected_="/x/y/z"}, InputOutput{.path_to_convert_="~/a",.home_dir_="/x/y/z",.expected_="/x/y/z/a"}, InputOutput{.path_to_convert_="~/.",.home_dir_="/x/y/z",.expected_="/x/y/z"}, InputOutput{.path_to_convert_="~/..",.home_dir_="/x/y/z",.expected_="/x/y"}, InputOutput{.path_to_convert_="~/k/../../t/./q",.home_dir_="/x/y/z",.expected_="/x/y/t/q"}))
std::ostream &	operator<< (std::ostream &out, const FlagAlias &alias)
static bool	LikelyFlag (const std::string &next_arg)
Result< bool >	ParseBool (const std::string &value, const std::string &name)
static std::string	XmlEscape (const std::string &s)
std::ostream &	operator<< (std::ostream &out, const Flag &flag)
std::vector< std::string >	ArgsToVec (int argc, char **argv)
static Separated	SeparateByEndOfOptionMark (std::vector< std::string > args)
static Result< void >	ConsumeFlagsImpl (const std::vector< Flag > &flags, std::vector< std::string > &args)
static Result< void >	ConsumeFlagsImpl (const std::vector< Flag > &flags, std::vector< std::string > &&args)
Result< void >	ConsumeFlags (const std::vector< Flag > &flags, std::vector< std::string > &args, const bool recognize_end_of_option_mark)
Result< void >	ConsumeFlags (const std::vector< Flag > &flags, std::vector< std::string > &&args, const bool recognize_end_of_option_mark)
Result< void >	ConsumeFlagsConstrained (const std::vector< Flag > &flags, std::vector< std::string > &args)
Result< void >	ConsumeFlagsConstrained (const std::vector< Flag > &flags, std::vector< std::string > &&args)
bool	WriteGflagsCompatXml (const std::vector< Flag > &flags, std::ostream &out)
Flag	VerbosityFlag (android::base::LogSeverity &value)
Flag	HelpFlag (const std::vector< Flag > &flags, std::string text)
static Result< void >	GflagsCompatBoolFlagSetter (const std::string &name, bool &value, const FlagMatch &match)
static Flag	GflagsCompatBoolFlagBase (const std::string &name)
Flag	HelpXmlFlag (const std::vector< Flag > &flags, std::ostream &out, bool &value, std::string text)
Flag	InvalidFlagGuard ()
Flag	UnexpectedArgumentGuard ()
Flag	GflagsCompatFlag (const std::string &name)
Flag	GflagsCompatFlag (const std::string &name, std::string &value)
template<typename T >
std::optional< T >	ParseInteger (const std::string &value)
template<typename T >
static Flag	GflagsCompatNumericFlagGeneric (const std::string &name, T &value)
Flag	GflagsCompatFlag (const std::string &name, int32_t &value)
template<typename T >
static Flag	GflagsCompatUnsignedNumericFlagGeneric (const std::string &name, T &value)
Flag	GflagsCompatFlag (const std::string &name, std::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< bool > &value, const bool default_value)
Result< bool >	HasHelpFlag (const std::vector< std::string > &args)
Flag	GflagsCompatFlag (const std::string &name, std::int32_t &value)
	TEST (FlagParser, DuplicateAlias)
	TEST (FlagParser, ConflictingAlias)
	TEST (FlagParser, StringFlag)
	TEST (FlagParser, NormalizedStringFlag)
std::optional< std::map< std::string, std::string > >	flagXml (const Flag &f)
	TEST (FlagParser, GflagsIncompatibleFlag)
	TEST (FlagParser, StringFlagXml)
	TEST (FlagParser, RepeatedStringFlag)
	TEST (FlagParser, RepeatedListFlag)
	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, VerbosityFlag)
	TEST (FlagParser, InvalidVerbosityFlag)
	TEST (FlagParser, InvalidFlagGuard)
	TEST (FlagParser, UnexpectedArgumentGuard)
	TEST (FlagParser, EndOfOptionMark)
	TEST (FlagParser, ConsumesConstrainedEquals)
	TEST (FlagParser, ConsumesConstrainedSeparated)
	TEST_F (FlagConsumesArbitraryTest, NoValues)
	TEST_F (FlagConsumesArbitraryTest, OneValue)
	TEST_F (FlagConsumesArbitraryTest, TwoValues)
	TEST_F (FlagConsumesArbitraryTest, NoValuesOtherFlag)
	TEST_F (FlagConsumesArbitraryTest, OneValueOtherFlag)
	TEST_F (FlagConsumesArbitraryTest, TwoValuesOtherFlag)
Result< void >	ValidateSetupWizardMode (const std::string &setupwizard_mode)
bool	InSandbox ()
std::vector< std::string >	GetCreatedFileListFromInotifyFd (int fd)
std::vector< std::string >	GetFileListFromInotifyFd (int fd, uint32_t mask)
Result< Json::Value >	ParseJson (std::string_view input)
Result< Json::Value >	LoadFromFile (SharedFD json_fd)
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 std::uint8_t mac[6])
std::string	Ipv6ToString (const std::uint8_t ip[16])
void	GenerateMobileMacForInstance (int index, std::uint8_t out[6])
void	GenerateEthMacForInstance (int index, std::uint8_t out[6])
void	GenerateWifiMacForInstance (int index, std::uint8_t out[6])
void	GenerateCorrespondingIpv6ForMac (const std::uint8_t mac[6], std::uint8_t out[16])
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)
static std::vector< std::string >	TokenizeByNullChar (const std::string &input)
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)
std::string	ResultErrorFormat (bool color)
template<typename T >
T	OutcomeDereference (std::optional< T > &&value)
template<typename T >
std::conditional_t< std::is_void_v< T >, bool, 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)
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)
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)
static Result< void >	Set (const FlagMatch &match, SharedFD &out)
Flag	SharedFDFlag (SharedFD &out)
Flag	SharedFDFlag (const std::string &name, SharedFD &out)
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::vector< std::string >	ArgsToVec (char **argv)
std::unordered_map< std::string, std::string >	EnvpToMap (char **envp)
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::ostream &	operator<< (std::ostream &out, const Command &command)
int	Execute (const std::vector< std::string > &commands, const std::vector< std::string > &envs)
int	Execute (const std::vector< std::string > &commands)
Result< siginfo_t >	Execute (const std::vector< std::string > &commands, SubprocessOptions subprocess_options, int wait_options)
Result< siginfo_t >	Execute (const std::vector< std::string > &commands, const std::vector< std::string > &envs, 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)
void	AppendInNetworkByteOrder (Message *msg, const std::uint8_t b)
void	AppendInNetworkByteOrder (Message *msg, const std::uint16_t s)
void	AppendInNetworkByteOrder (Message *msg, const std::uint32_t w)
void	AppendInNetworkByteOrder (Message *msg, const std::int32_t w)
void	AppendInNetworkByteOrder (Message *msg, const std::string &str)
void	AppendToMessage (Message *)
template<typename T , typename... Ts>
void	AppendToMessage (Message *msg, T v, Ts... vals)
template<typename... Ts>
Message	CreateMessage (Ts... vals)
std::string	FromSeverity (const android::base::LogSeverity severity)
Result< LogSeverity >	ToSeverity (const std::string &value)
static LogSeverity	GuessSeverity (const std::string &env_var, LogSeverity default_value)
LogSeverity	ConsoleSeverity ()
LogSeverity	LogFileSeverity ()
static std::pair< int, int >	CountSizeAndNewLines (const char *message)
template<typename F , typename... Args>
static void	SplitByLines (const char *msg, const F &log_function, Args &&... args)
std::string	StderrOutputGenerator (const struct tm &now, int pid, uint64_t tid, LogSeverity severity, const char *tag, const char *file, unsigned int line, const char *message)
std::string	StripColorCodes (const std::string &str)
static std::vector< SeverityTarget >	SeverityTargetsForFiles (const std::vector< std::string > &files)
TeeLogger	LogToStderr (const std::string &log_prefix, MetadataLevel stderr_level, std::optional< android::base::LogSeverity > stderr_severity)
TeeLogger	LogToFiles (const std::vector< std::string > &files, const std::string &log_prefix)
TeeLogger	LogToStderrAndFiles (const std::vector< std::string > &files, const std::string &log_prefix, MetadataLevel stderr_level, std::optional< android::base::LogSeverity > stderr_severity)
std::string	StderrOutputGenerator (const struct tm &now, int pid, uint64_t tid, android::base::LogSeverity severity, const char *tag, const char *file, unsigned int line, const char *message)
template<typename T >
constexpr std::string_view	TypeName ()
template<auto T>
constexpr std::string_view	ValueName ()
	TEST_P (OneEachTest, GetAnyAvailableOne)
	INSTANTIATE_TEST_SUITE_P (CvdIdAllocator, OneEachTest, testing::Values(std::vector< unsigned >{}, std::vector< unsigned >{1}, std::vector< unsigned >{1, 22, 3, 43, 5}))
	TEST_F (CvdIdAllocatorTest, ClaimAll)
	TEST_F (CvdIdAllocatorTest, StrideBeyond)
	TEST_F (CvdIdAllocatorTest, Consecutive)
	TEST_F (CvdIdAllocatorTest, Take)
	TEST_F (CvdIdAllocatorTest, TakeAll)
	TEST_F (CvdIdAllocatorTest, TakeRange)
	TEST_F (CvdIdAllocatorTest, Reclaim)
	TEST (CvdIdAllocatorExpandTest, Expand)
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 ()
Result< void >	WaitForUnixSocket (const std::string &path, int timeoutSec)
Result< void >	WaitForUnixSocketListeningWithoutConnect (const std::string &path, int timeoutSec)
static Result< std::string >	InterfaceName (const CuttlefishConfig::InstanceSpecific &instance, const std::string &name)
Result< IfaceConfig >	DefaultNetworkInterfaces (const CuttlefishConfig::InstanceSpecific &instance)
std::optional< IfaceConfig >	AllocateNetworkInterfaces ()
Result< int >	AssembleCvdMain (int argc, char **argv)
void	PackRamdisk (const std::string &ramdisk_stage_dir, const std::string &output_ramdisk)
void	UnpackRamdisk (const std::string &original_ramdisk_path, const std::string &ramdisk_stage_dir)
Result< std::string >	UnpackBootImage (const std::string &boot_image_path, const std::string &unpack_dir)
bool	UnpackVendorBootImageIfNotUnpacked (const std::string &vendor_boot_image_path, const std::string &unpack_dir)
Result< void >	RepackBootImage (const Avb &avb, const std::string &new_kernel_path, const std::string &boot_image_path, const std::string &new_boot_image_path, const std::string &build_dir)
bool	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)
bool	RepackVendorBootImageWithEmptyRamdisk (const std::string &vendor_boot_image_path, const std::string &new_vendor_boot_image_path, const std::string &unpack_dir, bool bootconfig_supported)
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< std::unordered_map< std::string, std::string > >	BootconfigArgsFromConfig (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance)
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)
static uint64_t	AvailableSpaceAtPath (const std::string &path)
Result< void >	CreateDynamicDiskFiles (const FetcherConfig &fetcher_config, const CuttlefishConfig &config, const SystemImageDirFlag &system_image_dir)
Result< void >	InitializeAccessKregistryImage (const CuttlefishConfig::InstanceSpecific &instance)
std::vector< ImagePartition >	AndroidCompositeDiskConfig (const CuttlefishConfig::InstanceSpecific &instance, const MetadataImage &metadata_image, const MiscImage &misc_image, const SystemImageDirFlag &system_image_dir)
std::vector< ImagePartition >	AndroidEfiLoaderCompositeDiskConfig (const CuttlefishConfig::InstanceSpecific &instance, const MetadataImage &metadata, const MiscImage &misc, 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)
Result< void >	InitializeHwcomposerPmemImage (const CuttlefishConfig::InstanceSpecific &instance)
Result< void >	RepackKernelRamdisk (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance, const Avb &avb)
std::vector< ImagePartition >	LinuxCompositeDiskConfig (const CuttlefishConfig::InstanceSpecific &instance)
DiskBuilder	OsCompositeDiskBuilder (const CuttlefishConfig &config, const CuttlefishConfig::InstanceSpecific &instance, const std::optional< ChromeOsStateImage > &chrome_os_state, const MetadataImage &metadata, const MiscImage &misc, 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 FetcherConfig &fetcher_config, 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 FetcherConfig &fetcher_config, 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)
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)
std::string	GetConfigFilePath (const CuttlefishConfig &config)
gfxstream::proto::GraphicsAvailability	GetGraphicsAvailabilityWithSubprocessCheck ()
Result< std::string >	ConfigureGpuSettings (const gfxstream::proto::GraphicsAvailability &graphics_availability, const std::string &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)
Result< std::vector< GuestConfig > >	ReadGuestConfig (const BootImageFlag &boot_image, const KernelPathFlag &kernel_path, const SystemImageDirFlag &system_image_dir)
bool	IsKernelModuleSigned (const char *path)
constexpr bool	IsKernelModuleSigned (const std::string &path)
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::InstanceSpecific &const_instance, CuttlefishConfig::MutableInstanceSpecific &instance)
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 &image_path, const std::string &vbmeta_path)
std::vector< std::string >	Dedup (std::vector< std::string > &&vec)
bool	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< bool >	WriteFsConfig (const char *output_path, const std::string &fs_root, const std::string &mount_point)
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)
template<typename ProtoType >
Result< ProtoType >	ParseTextProtoConfigHelper (const std::string &config_path)
Result< const std::string >	GetDefaultConfigFile ()
Result< AcloudConfig >	LoadAcloudConfig (const std::string &user_config_path)
Result< void >	EmptyCache (const std::string &cache_directory)
Result< std::size_t >	GetCacheSize (const std::string &cache_directory)
Result< PruneResult >	PruneCache (const std::string &cache_directory, const std::size_t allowed_size_gb)
std::unique_ptr< CvdCommandHandler >	NewAcloudCommand (CommandSequenceExecutor &executor)
bool	IsSubOperationSupported (const CommandRequest &request)
Result< void >	PrepareForAcloudDeleteCommand (const std::string &host_artifacts)
Result< std::string >	FindMiscInfo (const std::string &image_dir)
Result< std::string >	FindImageDir (const std::string &image_dir)
Result< std::string >	GetImageForPartition (std::string const &partition_name, std::string const &image_dir, const std::map< std::string, std::string > &image_paths)
Result< void >	_RewriteMiscInfo (const std::string &output_file, const std::string &input_file, const std::string &lpmake_path, const std::function< Result< std::string >(const std::string &)> &get_image)
std::unique_ptr< CvdCommandHandler >	NewAcloudMixSuperImageCommand ()
std::unique_ptr< CvdCommandHandler >	NewAcloudTranslatorCommand (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdBugreportCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdCacheCommandHandler ()
std::unique_ptr< CvdCommandHandler >	NewCvdClearCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdCmdlistHandler (CommandSequenceExecutor &executor)
std::unique_ptr< CvdCommandHandler >	NewCvdCreateCommandHandler (InstanceManager &instance_manager, CommandSequenceExecutor &executor, InstanceLockFileManager &lock_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdDisplayCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdEnvCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdFetchCommandHandler ()
std::unique_ptr< CvdCommandHandler >	NewCvdFleetCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdHelpHandler (const std::vector< std::unique_ptr< CvdCommandHandler > > &server_handlers)
std::unique_ptr< CvdCommandHandler >	NewLintCommand ()
std::unique_ptr< CvdCommandHandler >	NewLoadConfigsCommand (CommandSequenceExecutor &executor, InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewLoginCommand ()
std::unique_ptr< CvdCommandHandler >	NewCvdNoopHandler ()
std::unique_ptr< CvdCommandHandler >	NewCvdDevicePowerBtnCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdDevicePowerwashCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewRemoveCvdCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdResetCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdDeviceRestartCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdSnapshotCommandHandler (InstanceManager &instance_manager)
static Result< void >	ConsumeDaemonModeFlag (cvd_common::Args &args)
static Result< void >	CvdResetGroup (const LocalInstanceGroup &group)
std::unique_ptr< CvdCommandHandler >	NewCvdStartCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdStatusCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewCvdStopCommandHandler (InstanceManager &instance_manager)
std::unique_ptr< CvdCommandHandler >	NewTryAcloudCommand ()
std::unique_ptr< CvdCommandHandler >	NewCvdVersionHandler ()
Result< cvd_common::Args >	ExtractCvdArgs (cvd_common::Args &args)
	TEST (FrontlineParserTest, SelectorArgs)
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)
std::vector< std::string >	GenerateMetricsFlags (const EnvironmentSpecification &config)
std::vector< std::string >	GenerateMetricsFlags (const cvd::config::EnvironmentSpecification &)
	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 (FlagsParserTest, ParseInvalidJson)
	TEST (FlagsParserTest, ParseJsonWithSpellingError)
	TEST (FlagsParserTest, ParseBasicJsonSingleInstances)
	TEST (FlagsParserTest, ParseBasicJsonTwoInstances)
	TEST (BootFlagsParserTest, ParseNetSimFlagEmptyJson)
	TEST (BootFlagsParserTest, ParseNetSimFlagEnabled)
	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)
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::optional< std::string > >	GenerateDisplayFlag (const EnvironmentSpecification &cfg)
bool	RecordScreen (const Instance &instance)
std::string	GpuMode (const Instance &instance)
Result< std::vector< std::string > >	GenerateGraphicsFlags (const EnvironmentSpecification &cfg)
Result< std::vector< std::string > >	GenerateGraphicsFlags (const cvd::config::EnvironmentSpecification &)
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 std::uint32_t	Cpus (const Instance &instance)
static std::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 Result< 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, ParseTwoInstancesCpuFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesCpuFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesQemu)
	TEST (VmFlagsParserTest, ParseTwoInstancesCpuFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesMemoryFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesMemoryFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesMemoryFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSdCardFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSdCardFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSdCardFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesVmManagerFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesVmManagerFlagDefault)
	TEST (VmFlagsParserTest, ParseOneInstanceSetupWizardInvalidValue)
	TEST (VmFlagsParserTest, ParseTwoInstancesSetupWizardFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSetupWizardFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSetupWizardFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesUuidFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesUuidFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesUuidFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSandboxFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSandboxFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSandboxFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSimpleMediaDeviceFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSimpleMediaDeviceFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesSimpleMediaDeviceFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesV4l2ProxyFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesV4l2ProxyFlagPartialJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesV4l2ProxyFlagFullJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesCustomActionsFlagEmptyJson)
	TEST (VmFlagsParserTest, ParseTwoInstancesCustomActionsFlagPartialJson)
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::ostream &	operator<< (std::ostream &out, const Override &override)
Result< LoadFlags >	GetFlags (std::vector< std::string > &args, const std::string &working_directory)
Result< CvdFlags >	GetCvdFlags (const LoadFlags &flags)
	TEST (MetricsFlagsParserTest, ParseOneInstanceMetricsReportValidValue)
	TEST (MetricsFlagsParserTest, ParseOneInstanceMetricsReportInvalidValue)
	TEST (MetricsFlagsParserTest, ParseOneInstancesMetricsReportFlagEmptyJson)
	TEST (MetricsFlagsParserTest, ParseTwoInstancesMetricsReportFlagEmptyJson)
std::string	InsName (const Instance &instance)
std::vector< std::string >	ParseSelectorConfigs (const EnvironmentSpecification &config)
std::vector< std::string >	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, const int expected_exit_code)
Result< Command >	ConstructCommand (const ConstructCommandParam &param)
Result< Command >	ConstructCvdHelpCommand (const std::string &bin_file, cvd_common::Envs envs, const std::vector< std::string > &subcmd_args, const CommandRequest &request)
Result< Command >	ConstructCvdGenericNonHelpCommand (const ConstructNonHelpForm &request_form, const CommandRequest &request)
std::string	NoGroupMessage (const CommandRequest &request)
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::string	GetFetchLogsFileName (const std::string &target_directory)
Result< std::vector< 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< 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 std::string	DevicePatternString (const std::unordered_map< std::string, std::set< int > > &device_to_ids_map)
static Result< TypeAndId >	ParseMatchedLine (const std::smatch &device_string_match)
Result< void >	KillCvdServerProcess ()
Result< void >	KillAllCuttlefishInstances (bool clear_runtime_dirs)
Result< void >	ForcefullyStopGroup (const uid_t any_id_in_group)
Result< std::vector< GroupProcInfo > >	CollectRunCvdGroups ()
Result< Json::Value >	FetchInstanceStatus (LocalInstance &instance, std::chrono::seconds timeout)
bool	IsServerModeExpected (const std::string &exec_file)
void	ImportResourcesFromRunningServer (std::vector< std::string > args)
std::string	ServerSocketPath ()
std::string	GetUserType ()
void	PrintDataCollectionNotice (bool colorful=true)
	TEST (CvdAutoGenId, CvdTwoFollowedByFive)
	TEST (CvdBasic, CvdDefaultStart)
	TEST (CvdClear, ClearAfterThreeStarts)
	TEST (CvdHelpFlagCollect, LauncCvd)
	TEST (CvdDriver, CvdHelp)
	TEST (CvdDriver, CvdOnly)
	TEST (CvdDriver, CvdHelpWrong)
	TEST (CvdSubtool, CvdStopHelp)
	TEST (CvdSubtool, CvdStartHelp)
	TEST (CvdInstanceIds, CvdTakenInstanceIds)
int	NumberOfOccurrences (const std::string &str, const std::string &substr)
Result< std::string >	AndroidHostPath (const cvd_common::Envs &envs)
template<typename T >
std::ostream &	operator<< (std::ostream &out, const std::vector< T > &v)
Result< android::base::LogSeverity >	EncodeVerbosity (const std::string &verbosity)
Result< std::string >	VerbosityToString (const android::base::LogSeverity verbosity)
android::base::LogSeverity	SetMinimumVerbosity (const android::base::LogSeverity severity)
Result< android::base::LogSeverity >	SetMinimumVerbosity (const std::string &severity)
android::base::LogSeverity	GetMinimumVerbosity ()
std::string	CvdDir ()
std::string	PerUserDir ()
std::string	PerUserCacheDir ()
std::string	InstanceDatabasePath ()
std::string	InstanceLocksPath ()
std::string	DefaultBaseDir ()
Result< std::string >	GroupDirFromHome (std::string_view dir)
std::string	AssemblyDirFromHome (const std::string &group_home_dir)
template<typename... Ts>
	Overload (Ts...) -> Overload< Ts... >
template<typename Ostream , typename... Args>
Ostream &	ConcatToStream (Ostream &out, Args &&... args)
template<typename... Args>
std::string	ConcatToString (Args &&... args)
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)
CuttlefishLogEvent *	sampleEvent ()
std::string	ProtoToString (LogEvent *event)
	TEST (MacAddressTest, ValidMacAddress)
	TEST (MacAddressTest, MacAddressFormat)
Result< int >	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)
Result< std::optional< MonitorCommand > >	GnssGrpcProxyServer (const CuttlefishConfig::InstanceSpecific &instance, GrpcSocketCreator &grpc_socket)
fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific >, InputConnectionsProvider, LogTeeCreator >	VhostInputDevicesComponent ()
fruit::Component< fruit::Required< const CuttlefishConfig::InstanceSpecific >, KernelLogPipeProvider >	KernelLogMonitorComponent ()
std::string	LogcatInfo (const CuttlefishConfig::InstanceSpecific &instance)
Result< MonitorCommand >	LogcatReceiver (const CuttlefishConfig::InstanceSpecific &instance)
fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific, LogTeeCreator > >	McuComponent ()
std::optional< MonitorCommand >	MetricsService (const CuttlefishConfig &config)
static StopperResult	StopModemSimulator (int id)
Result< std::optional< MonitorCommand > >	ModemSimulator (const CuttlefishConfig::InstanceSpecific &instance)
fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::InstanceSpecific > >	NetsimServerComponent ()
Result< MonitorCommand >	NfcConnector (const CuttlefishConfig::EnvironmentSpecific &environment, const CuttlefishConfig::InstanceSpecific &instance)
fruit::Component< fruit::Required< const CuttlefishConfig, const CuttlefishConfig::EnvironmentSpecific, const CuttlefishConfig::InstanceSpecific, LogTeeCreator, WmediumdServer > >	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, InputConnectionsProvider, 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 &config, const CuttlefishConfig::InstanceSpecific &instance)
fruit::Component< fruit::Required< const CuttlefishConfig, LogTeeCreator, const CuttlefishConfig::InstanceSpecific > >	VhostDeviceVsockComponent ()
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 (std::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)
std::string	ValidateMetricsConfirmation (std::string use_metrics)
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[])
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)
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 (IoTransferMsg, 12)
	ASSERT_VALID_MSG_TYPE (IoStatusMsg, 16)
Result< void >	EnforceVbMetaSize (const std::string &path)
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, const 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 (const std::string &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)
fruit::Component< fruit::Required< SystemImageDirFlag >, ConfigFlag >	ConfigFlagComponent ()
fruit::Component< ConfigFlag >	ConfigFlagPlaceholder ()
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	IsValidMetricsConfigs (int value)
Result< void >	CreateBlankImage (const std::string &image, int num_mb, const std::string &image_fmt)
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)
Result< std::optional< CuttlefishConfig::DisplayConfig > >	ParseDisplayConfig (const std::string &flag)
Result< std::vector< CuttlefishConfig::DisplayConfig > >	ParseDisplayConfigsFromArgs (std::vector< std::string > &args)
Result< void >	MakeFatImage (const std::string &data_image, int data_image_mb, int offset_num_mb)
bool	CanGenerateEsp (Arch arch)
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)
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	PrepareESP (const std::string &image_path, Arch arch)
EspBuilder	AddGrubConfig (const std::string &config)
std::ostream &	operator<< (std::ostream &out, ExternalNetworkMode net)
Result< ExternalNetworkMode >	ParseExternalNetworkMode (std::string_view str)
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)
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< std::int32_t > >	ParseBaseInstanceFlag (std::vector< std::string > &flags)
static Result< std::optional< std::int32_t > >	ParseNumInstancesFlag (std::vector< std::string > &flags)
static Result< std::vector< std::int32_t > >	ParseInstanceNums (const std::string &instance_nums_str)
static Result< std::vector< std::int32_t > >	ParseInstanceNumsFlag (std::vector< std::string > &flags)
static Result< std::optional< std::int32_t > >	GflagsBaseInstanceFlag ()
static Result< std::optional< std::int32_t > >	GflagsNumInstancesFlag ()
static Result< std::vector< std::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	MetricsBinary ()
std::string	MkbootimgBinary ()
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 ()
void	DefaultSubprocessLogging (char *argv[], MetadataLevel stderr_level)
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)
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)
struct	__attribute__ ((packed)) GptHeader
Result< const std::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 >	CreateCompositeDisk (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	SendHelper (const std::string &queue_name, const std::string &message)
key_t	GenerateQueueKey (const char *str)
void	alpha_blend_layer (std::uint8_t *frame_pixels, std::uint32_t h, std::uint32_t w, std::uint8_t *overlay)
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::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::ostream &	operator<< (std::ostream &out, const DeviceBuildString &build_string)
bool	operator== (const DeviceBuildString &lhs, const DeviceBuildString &rhs)
bool	operator!= (const DeviceBuildString &lhs, const DeviceBuildString &rhs)
std::ostream &	operator<< (std::ostream &out, const DirectoryBuildString &build_string)
bool	operator== (const DirectoryBuildString &lhs, const DirectoryBuildString &rhs)
bool	operator!= (const DirectoryBuildString &lhs, const DirectoryBuildString &rhs)
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 (const std::string &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)
Result< ReadableZip >	OpenZip (BuildApi &build_api, const Build &build, const std::string &name)
std::string	GetBuildZipName (const Build &build, const std::string &name)
bool	EnsureCacheDirectory (const std::string &cache_base_path)
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, 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)
int	main (int argc, char **argv)
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)
Result< std::unique_ptr< CredentialSource > >	GetCredentialSource (HttpClient &http_client, const std::string &credential_source, const std::string &oauth_filepath, const bool use_gce_metadata, const std::string &credential_filepath, const std::string &service_account_filepath)
Result< std::unique_ptr< CredentialSource > >	CreateRefreshTokenCredentialSource (HttpClient &http_client, const std::string &client_id, const std::string &client_secret, const std::string &refresh_token)
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	UrlEscape (std::string_view text)
Result< std::unique_ptr< CredentialSource > >	Oauth2LoginLocal (HttpClient &http_client, const Oauth2ConsentRequest &request)
Result< std::unique_ptr< CredentialSource > >	Oauth2LoginSsh (HttpClient &http_client, const Oauth2ConsentRequest &request)
Result< std::unique_ptr< CredentialSource > >	CredentialForScopes (HttpClient &http_client, const std::vector< std::string > &scopes)
Result< SeekableZipSource >	BufferZipSource (SeekableZipSource inner, size_t buffer_size)
Result< SeekableZipSource >	CacheZipSource (SeekableZipSource inner, std::string file_path)
Result< SeekableZipSource >	ZipSourceFromUrl (HttpClient &http_client, const std::string &url, std::vector< std::string > headers)
std::string	Serialize (const DisjointRangeSet &range_set)
Result< DisjointRangeSet >	DeserializeDisjointRangeSet (std::string_view data)
Result< void >	Copy (ReadableZipSource &input, WritableZipSource &output)
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, const std::string &zip_path, const std::string &host_path)
Result< std::string >	ReadToString (ReadableZipSource &source)
Result< std::string >	ReadToString (ZipSourceReader &reader)
Result< void >	AddStringAt (WritableZip &zip, const std::string &data, const std::string &zip_path)

Variables
constexpr char	kEbtablesName [] = "ebtables"
constexpr char	kEbtablesLegacyName [] = "ebtables-legacy"
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 uint16_t	kCurHeaderVersion = 1
	Current supported Header version number. More...
constexpr uint16_t	kMinHeaderVersion = 1
	Oldest compatible header version number. More...
const std::map< RequestType, const char * >	RequestTyToStrMap
const std::map< std::string, RequestType >	StrToRequestTyMap
const std::map< std::string, IfaceType >	StrToIfaceTyMap
const std::map< IfaceType, std::string >	IfaceTyToStrMap
const std::map< RequestStatus, std::string >	ReqStatusToStrMap
const std::map< std::string, RequestStatus >	StrToReqStatusMap
constexpr char	kDefaultLocation []
static constexpr int	kSendFlags = 0
static constexpr int	kRecvFlags = 0
char	pipe_message [] = "Testing the pipe"
static constexpr char	kProcDir [] = "/proc"
constexpr int	DISK_SIZE_SHIFT = 16
constexpr int	PARTITION_SIZE_SHIFT = 12
constexpr std::string_view	kDefaultInterfacePrefix = "cvd"
static constexpr char	kImageName [] = "chromeos_state.img"
static constexpr int	kImageSizeMb = 8096
static constexpr char	kFilesystemFormat [] = "ext4"
static constexpr size_t	kMetadataImageMb = 64
static constexpr size_t	kMetadataImageBytes = kMetadataImageMb << 20
constexpr std::size_t	kDefaultCacheSizeGb = 25
static constexpr char	kMixSuperImageHelpMessage []
const std::string	_MISC_INFO_FILE_NAME = "misc_info.txt"
const std::string	_TARGET_FILES_META_DIR_NAME = "META"
const std::string	_TARGET_FILES_IMAGES_DIR_NAME = "IMAGES"
const std::string	_SYSTEM_IMAGE_NAME_PATTERN = "system.img"
const std::string	_SYSTEM_EXT_IMAGE_NAME_PATTERN = "system_ext.img"
const std::string	_PRODUCT_IMAGE_NAME_PATTERN = "product.img"
static constexpr char	kTranslatorHelpMessage []
constexpr char	kSummaryHelpText []
static constexpr char	kHelpMessage []
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
static constexpr char	kTerminalBoldRed [] = "\033[0;1;31m"
static constexpr char	kTerminalCyan [] = "\033[0;36m"
static constexpr char	kTerminalRed [] = "\033[0;31m"
static constexpr char	kTerminalReset [] = "\033[0m"
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 [] = ""
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 char	kDefaultOPeratorControlSocketPath []
constexpr char	kInternalServerFd [] = "INTERNAL_server_fd"
static std::mutex	verbosity_mutex
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"
constexpr char	kLaunchedByAcloud [] = "LAUNCHED_BY_ACLOUD"
constexpr android::base::LogSeverity	kCvdDefaultVerbosity = android::base::INFO
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"
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 {}
static constexpr char	kGreenColor [] = "\033[1;32m"
static constexpr char	kResetColor [] = "\033[0m"
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 uint	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_"
static constexpr int	kSendFlags = 0
static constexpr int	kRecvFlags = 0
constexpr uint8_t	VIRTIO_SND_CHMAP_MAX_SIZE = 18
const uint32_t	VIOS_VERSION = 2
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	kGpuModeAuto [] = "auto"
constexpr char	kGpuModeCustom [] = "custom"
constexpr char	kGpuModeDrmVirgl [] = "drm_virgl"
constexpr char	kGpuModeGfxstream [] = "gfxstream"
constexpr char	kGpuModeGfxstreamGuestAngle [] = "gfxstream_guest_angle"
constexpr char	kGpuModeGfxstreamGuestAngleHostSwiftShader []
constexpr char	kGpuModeGfxstreamGuestAngleHostLavapipe []
constexpr char	kGpuModeGuestSwiftshader [] = "guest_swiftshader"
constexpr char	kGpuModeNone [] = "none"
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	kEnableHostUwbConnector [] = "enable_host_uwb_connector"
static constexpr char	kPicaUciPort [] = "pica_uci_port"
static constexpr char	kEnableHostBluetooth [] = "enable_host_bluetooth"
static constexpr char	kEnableHostBluetoothConnector []
static constexpr char	kEnableAutomotiveProxy [] = "enable_automotive_proxy"
static constexpr char	kVhalProxyServerPort [] = "vhal_proxy_server_port"
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	kNetsimRadios [] = "netsim_radios"
static constexpr char	kNetsimInstanceNum [] = "netsim_instance_num"
static constexpr char	kNetsimConnectorInstanceNum []
static constexpr char	kNetsimArgs [] = "netsim_args"
static constexpr char	kEnableMetrics [] = "enable_metrics"
static constexpr char	kMetricsBinary [] = "metrics_binary"
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	kBootImage [] = "boot_image"
static constexpr char	kNewBootImage [] = "new_boot_image"
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	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	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	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	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	kUseAllocd [] = "use_allocd"
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	kConfigServerPort [] = "config_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	kEnableTapDevices [] = "enable_tap_devices"
static constexpr char	kFrameSockPath [] = "frame_sock_path"
static constexpr char	kWifiMacPrefix [] = "wifi_mac_prefix"
static constexpr char	kStartVhalProxyServer [] = "start_vhal_proxy_server"
static constexpr char	kAudioOutputStreamsCount [] = "audio_output_streams_count"
constexpr const char	kDisplayFlag [] = "display"
constexpr const char	kDisplayHelp []
static constexpr char	kBootSrcPathIA32 []
static constexpr char	kBootDestPathIA32 [] = "/EFI/BOOT/BOOTIA32.EFI"
static constexpr char	kBootSrcPathAA64 []
static constexpr char	kBootDestPathAA64 [] = "/EFI/BOOT/BOOTAA64.EFI"
static constexpr char	kBootDestPathRiscV64 [] = "/EFI/BOOT/BOOTRISCV64.EFI"
static constexpr char	kMultibootModuleSrcPathIA32 []
static constexpr char	kMultibootModuleDestPathIA32 []
static constexpr char	kMultibootModuleSrcPathAA64 []
static constexpr char	kMultibootModuleDestPathAA64 []
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	kGrubModulesX86
static constexpr char	kGrubModulesPath [] = "/usr/lib/grub/"
static constexpr char	kGrubModulesX86Name [] = "i386-efi"
constexpr const char	kTouchpadFlag [] = "touchpad"
constexpr const char	kTouchpadHelp []
constexpr int	GPT_NUM_PARTITIONS = 128
constexpr int	kSectorSizeShift = 9
constexpr int	kSectorSize = 1 << kSectorSizeShift
const uint32_t	MAX_MSG_SIZE = 200
constexpr char	kCfMetricsQueueName [] = "cf_metrics_msg_queue"
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 char	kAndroidBuildApiScope []

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)>

f_func

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

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)>

Message

using cuttlefish::Message = typedef std::vector<std::uint8_t>

MiscInfo

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

msg_buffer

typedef struct cuttlefish::msg_buffer cuttlefish::msg_buffer

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&)>

Result

template<typename T >

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

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>

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

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

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

DeviceType

enum class cuttlefish::DeviceType

strong

Enumerator
Unknown
Phone
Wear
Auto
Foldable
Tv
Minidroid
Go

ExternalNetworkMode

enum class cuttlefish::ExternalNetworkMode

strong

Enumerator
kUnknown
kTap
kSlirp

FileSource

enum class cuttlefish::FileSource

strong

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

FlagAliasMode

enum class cuttlefish::FlagAliasMode

strong

Enumerator
kFlagPrefix
kFlagExact
kFlagConsumesFollowing
kFlagConsumesArbitrary

GptPartitionType

enum class cuttlefish::GptPartitionType

strong

Enumerator
kLinuxFilesystem
kEfiSystemPartition

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

IfaceType [1/2]

enum class cuttlefish::IfaceType : uint16_t

strong

Defines interface types supported by allocd.

Enumerator
Invalid
mtap
wtap
wifiap
etap
wbr
ebr
Invalid
mtap
wtap
wifiap
etap
wbr
ebr

IfaceType [2/2]

enum class cuttlefish::IfaceType : uint16_t

strong

Defines interface types supported by allocd.

Enumerator
Invalid
mtap
wtap
wifiap
etap
wbr
ebr
Invalid
mtap
wtap
wifiap
etap
wbr
ebr

InUseState

enum class cuttlefish::InUseState : char

strong

Enumerator
kInUse
kNotInUse

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

MetadataLevel

enum class cuttlefish::MetadataLevel

strong

Enumerator
FULL
ONLY_MESSAGE
TAG_AND_MESSAGE

MetricsExitCodes

enum cuttlefish::MetricsExitCodes : int

Enumerator
kSuccess
kMetricsError
kInvalidHostConfiguration

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

RequestStatus [1/2]

enum class cuttlefish::RequestStatus : uint16_t

strong

Enumerator
Invalid
Pending
Success
Failure
Invalid
Pending
Success
Failure

RequestStatus [2/2]

enum class cuttlefish::RequestStatus : uint16_t

strong

Enumerator
Invalid
Pending
Success
Failure
Invalid
Pending
Success
Failure

RequestType [1/2]

enum class cuttlefish::RequestType : uint16_t

strong

Defines operations supported by allocd.

Enumerator
Invalid
ID
CreateInterface
DestroyInterface
StopSession
Shutdown
Invalid
ID
CreateInterface
DestroyInterface
StopSession
Shutdown

RequestType [2/2]

enum class cuttlefish::RequestType : uint16_t

strong

Defines operations supported by allocd.

Enumerator
Invalid
ID
CreateInterface
DestroyInterface
StopSession
Shutdown
Invalid
ID
CreateInterface
DestroyInterface
StopSession
Shutdown

ResourceType

enum class cuttlefish::ResourceType

strong

Enumerator
Invalid
MobileIface
EthernetIface
EthernetBridge

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

SecureHal

enum class cuttlefish::SecureHal

strong

Enumerator
kGuestGatekeeperInsecure
kGuestKeymintInsecure
kGuestKeymintTrustyInsecure
kGuestStrongboxInsecure
kHostKeymintInsecure
kHostKeymintSecure
kHostGatekeeperInsecure
kHostGatekeeperSecure
kHostOemlockInsecure
kHostOemlockSecure

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
kStopFailure
kStopCrash
kStopSuccess

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)

)

_RewriteMiscInfo()

Result< void > cuttlefish::_RewriteMiscInfo	(	const std::string &	output_file,
		const std::string &	input_file,
		const std::string &	lpmake_path,
		const std::function< Result< std::string >(const std::string &)> &	get_image
	)

AbsolutePath()

std::string cuttlefish::AbsolutePath

(

const std::string &

path

)

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()

bool cuttlefish::AddGateway	(	const std::string &	name,
		const std::string &	gateway,
		const std::string &	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()

bool cuttlefish::AddTapIface

(

const std::string &

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	(	std::uint8_t *	frame_pixels,
		std::uint32_t	h,
		std::uint32_t	w,
		std::uint8_t *	overlay
	)

AndroidCompositeDiskConfig()

std::vector< ImagePartition > cuttlefish::AndroidCompositeDiskConfig	(	const CuttlefishConfig::InstanceSpecific &	instance,
		const MetadataImage &	metadata_image,
		const MiscImage &	misc_image,
		const SystemImageDirFlag &	system_image_dir
	)

AndroidEfiLoaderCompositeDiskConfig()

std::vector< ImagePartition > cuttlefish::AndroidEfiLoaderCompositeDiskConfig	(	const CuttlefishConfig::InstanceSpecific &	instance,
		const MetadataImage &	metadata,
		const MiscImage &	misc,
		const SystemImageDirFlag &	system_image_dir
	)

AndroidHostPath()

Result< std::string > cuttlefish::AndroidHostPath

(

const cvd_common::Envs &

envs

)

ApCompositeDiskBuilder()

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

AppendInNetworkByteOrder() [1/5]

void cuttlefish::AppendInNetworkByteOrder	(	Message *	msg,
		const std::int32_t	w
	)

AppendInNetworkByteOrder() [2/5]

void cuttlefish::AppendInNetworkByteOrder	(	Message *	msg,
		const std::string &	str
	)

AppendInNetworkByteOrder() [3/5]

void cuttlefish::AppendInNetworkByteOrder	(	Message *	msg,
		const std::uint16_t	s
	)

AppendInNetworkByteOrder() [4/5]

void cuttlefish::AppendInNetworkByteOrder	(	Message *	msg,
		const std::uint32_t	w
	)

AppendInNetworkByteOrder() [5/5]

void cuttlefish::AppendInNetworkByteOrder	(	Message *	msg,
		const std::uint8_t	b
	)

AppendToMessage() [1/2]

void cuttlefish::AppendToMessage ( Message *  )

inline

AppendToMessage() [2/2]

template<typename T , typename... Ts>

void cuttlefish::AppendToMessage	(	Message *	msg,
		T	v,
		Ts...	vals
	)

ArchiveContents()

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

(

const std::string &

archive

)

AreHardLinked()

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

ArgsToVec() [1/2]

std::vector< std::string > cuttlefish::ArgsToVec

(

char **

argv

)

ArgsToVec() [2/2]

std::vector< std::string > cuttlefish::ArgsToVec	(	int	argc,
		char **	argv
	)

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/8]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	IoStatusMsg	,
		16
	)

ASSERT_VALID_MSG_TYPE() [2/8]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	IoTransferMsg	,
		12
	)

ASSERT_VALID_MSG_TYPE() [3/8]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_chmap_info	,
		24
	)

ASSERT_VALID_MSG_TYPE() [4/8]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_jack_info	,
		24
	)

ASSERT_VALID_MSG_TYPE() [5/8]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_pcm_hdr	,
		8
	)

ASSERT_VALID_MSG_TYPE() [6/8]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_pcm_info	,
		32
	)

ASSERT_VALID_MSG_TYPE() [7/8]

cuttlefish::ASSERT_VALID_MSG_TYPE	(	virtio_snd_pcm_set_params	,
		24
	)

ASSERT_VALID_MSG_TYPE() [8/8]

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

(

)

AvailableSpaceAtPath()

static uint64_t cuttlefish::AvailableSpaceAtPath ( const std::string &  path )

static

AvbToolBinary()

std::string cuttlefish::AvbToolBinary

(

)

BluetoothConnector()

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

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
	)

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

)

BringUpIface()

bool cuttlefish::BringUpIface

(

const std::string &

name

)

BufferZipSource()

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

BuildAPImage()

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

static

BuildDlkmImage()

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

BuildOSImage()

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

static

BuildVbmetaImage()

Result< void > cuttlefish::BuildVbmetaImage	(	const std::string &	image_path,
		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
	)

CanGenerateEsp()

bool cuttlefish::CanGenerateEsp

(

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

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
	)

CheckExecNameFromStatus()

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

static

CheckProcessExitedNormally()

Result< void > cuttlefish::CheckProcessExitedNormally	(	siginfo_t	infop,
		const 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	(	const std::string &	name,
		const std::string &	ipaddr,
		const GatewayConfig &	config
	)

CleanupEthernetIface()

void cuttlefish::CleanupEthernetIface	(	const std::string &	name,
		const EthernetNetworkConfig &	config
	)

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

(

)

ConcatToStream()

template<typename Ostream , typename... Args>

Ostream & cuttlefish::ConcatToStream	(	Ostream &	out,
		Args &&...	args
	)

ConcatToString()

template<typename... Args>

std::string cuttlefish::ConcatToString

(

Args &&...

args

)

ConfigFlagComponent()

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

(

)

ConfigFlagPlaceholder()

fruit::Component< ConfigFlag > cuttlefish::ConfigFlagPlaceholder

(

)

ConfigureGpuSettings()

Result< std::string > cuttlefish::ConfigureGpuSettings	(	const gfxstream::proto::GraphicsAvailability &	graphics_availability,
		const std::string &	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::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

)

ConsoleSeverity()

android::base::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,
		cvd_common::Envs	envs,
		const std::vector< std::string > &	subcmd_args,
		const CommandRequest &	request
	)

ConstructTargetFilepath()

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

ConsumeDaemonModeFlag()

static Result< void > cuttlefish::ConsumeDaemonModeFlag ( cvd_common::Args &  args )

static

ConsumeFlags() [1/2]

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

ConsumeFlags() [2/2]

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

ConsumeFlagsConstrained() [1/2]

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

ConsumeFlagsConstrained() [2/2]

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

ConsumeFlagsImpl() [1/2]

static Result< void > cuttlefish::ConsumeFlagsImpl ( const std::vector< Flag > &  flags, std::vector< std::string > &&  args  )

static

ConsumeFlagsImpl() [2/2]

static Result< void > cuttlefish::ConsumeFlagsImpl ( const std::vector< Flag > &  flags, std::vector< std::string > &  args  )

static

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
	)

ConvertToSnapshotCmd()

Result< SnapshotCmd > cuttlefish::ConvertToSnapshotCmd

(

const std::string &

input

)

Copy() [1/2]

bool cuttlefish::Copy	(	const std::string &	from,
		const std::string &	to
	)

Copy() [2/2]

Result< void > cuttlefish::Copy	(	ReadableZipSource &	input,
		WritableZipSource &	output
	)

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

CountSizeAndNewLines()

static std::pair< int, int > cuttlefish::CountSizeAndNewLines ( const char *  message )

static

CpioBinary()

std::string cuttlefish::CpioBinary

(

)

Cpus()

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

static

CreateAudioServer()

std::unique_ptr< AudioServer > cuttlefish::CreateAudioServer

(

)

CreateBlankImage()

Result< void > cuttlefish::CreateBlankImage	(	const std::string &	image,
		int	num_mb,
		const std::string &	image_fmt
	)

CreateBridge()

bool cuttlefish::CreateBridge

(

const std::string &

name

)

CreateCompositeDisk()

Result< void > cuttlefish::CreateCompositeDisk	(	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.

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 FetcherConfig &	fetcher_config,
		const CuttlefishConfig &	config,
		const SystemImageDirFlag &	system_image_dir
	)

CreateEbtables()

bool cuttlefish::CreateEbtables	(	const std::string &	name,
		bool	use_ipv4,
		bool	use_ebtables_legacy
	)

CreateEthernetBridgeIface()

bool cuttlefish::CreateEthernetBridgeIface	(	const std::string &	name,
		const std::string &	ipaddr
	)

CreateEthernetIface()

bool cuttlefish::CreateEthernetIface	(	const std::string &	name,
		const std::string &	bridge_name,
		bool	has_ipv4_bridge,
		bool	has_ipv6_bridge,
		bool	use_ebtables_legacy
	)

CreateHardLink()

Result< std::string > cuttlefish::CreateHardLink	(	const std::string &	target,
		const std::string &	hardlink,
		const bool	overwrite_existing
	)

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

CreateMemFDWithData()

SharedFD cuttlefish::CreateMemFDWithData

(

const std::string &

data

)

CreateMessage()

template<typename... Ts>

Message cuttlefish::CreateMessage

(

Ts...

vals

)

CreateMetaInfo()

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

CreateMobileIface()

bool cuttlefish::CreateMobileIface	(	const std::string &	name,
		uint16_t	id,
		const std::string &	ipaddr
	)

CreateRefreshTokenCredentialSource()

Result< std::unique_ptr< CredentialSource > > cuttlefish::CreateRefreshTokenCredentialSource	(	HttpClient &	http_client,
		const std::string &	client_id,
		const std::string &	client_secret,
		const std::string &	refresh_token
	)

CreateSymLink()

Result< void > cuttlefish::CreateSymLink	(	const std::string &	target,
		const std::string &	link,
		const bool	overwrite_existing
	)

CreateTap()

bool cuttlefish::CreateTap

(

const std::string &

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::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

(

)

CvdResetGroup()

static Result< void > cuttlefish::CvdResetGroup ( const LocalInstanceGroup &  group )

static

CvdRuntimeDir()

std::string cuttlefish::CvdRuntimeDir

(

)

CvdStateHome()

Result< std::string > cuttlefish::CvdStateHome

(

)

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()

bool cuttlefish::DecodeBase64	(	const std::string &	data,
		std::vector< std::uint8_t > *	buffer
	)

Dedup()

std::vector< std::string > cuttlefish::Dedup

(

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

vec

)

DefaultBaseDir()

std::string cuttlefish::DefaultBaseDir

(

)

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

(

)

DefaultSubprocessLogging()

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

DefaultSwitchesSpec()

std::string cuttlefish::DefaultSwitchesSpec

(

)

DeleteIface()

bool cuttlefish::DeleteIface

(

const std::string &

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

(

const std::string &

name

)

DestroyEbtables()

bool cuttlefish::DestroyEbtables	(	const std::string &	name,
		bool	use_ipv4,
		bool	use_ebtables_legacy
	)

DestroyEthernetBridgeIface()

bool cuttlefish::DestroyEthernetBridgeIface	(	const std::string &	name,
		const std::string &	ipaddr
	)

DestroyEthernetIface()

bool cuttlefish::DestroyEthernetIface	(	const std::string &	name,
		bool	has_ipv4_bridge,
		bool	has_ipv6_bridge,
		bool	use_ebtables_legacy
	)

DestroyGateway()

bool cuttlefish::DestroyGateway	(	const std::string &	name,
		const std::string &	gateway,
		const std::string &	netmask
	)

DestroyIface()

bool cuttlefish::DestroyIface

(

const std::string &

name

)

DestroyMobileIface()

bool cuttlefish::DestroyMobileIface	(	const std::string &	name,
		uint16_t	id,
		const std::string &	ipaddr
	)

DeviceId()

std::string cuttlefish::DeviceId

(

const Instance &

instance

)

DevicePatternString()

static std::string cuttlefish::DevicePatternString ( const std::unordered_map< std::string, std::set< int > > &  device_to_ids_map )

static

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 FetcherConfig &	fetcher_config,
		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
	)

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

)

EbtablesBroute()

bool cuttlefish::EbtablesBroute	(	const std::string &	name,
		bool	use_ipv4,
		bool	add,
		bool	use_ebtables_legacy
	)

EbtablesFilter()

bool cuttlefish::EbtablesFilter	(	const std::string &	name,
		bool	use_ipv4,
		bool	add,
		bool	use_ebtables_legacy
	)

EchoServer()

MonitorCommand cuttlefish::EchoServer

(

GrpcSocketCreator &

grpc_socket

)

EchoServerBinary()

std::string cuttlefish::EchoServerBinary

(

)

EmptyCache()

Result< void > cuttlefish::EmptyCache

(

const std::string &

cache_directory

)

EmulateAbsolutePath()

Result< std::string > cuttlefish::EmulateAbsolutePath

(

const InputPathForm &

path_info

)

Returns emulated absolute path with a different process'/thread's context.

This is useful when daemon(0, 0)-started server process wants to figure out a relative path that came from its client.

The call mostly succeeds. It fails only if: home_dir isn't given so supposed to relies on the local SystemWideUserHome() but SystemWideUserHome() call fails.

EnableBootAnimation()

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

static

EnableSandbox()

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

static

EncodeBase64()

bool cuttlefish::EncodeBase64	(	const void *	data,
		std::size_t	size,
		std::string *	out
	)

EncodeVerbosity()

Result< android::base::LogSeverity > cuttlefish::EncodeVerbosity

(

const std::string &

verbosity

)

EnforceVbMetaSize()

Result< void > cuttlefish::EnforceVbMetaSize

(

const std::string &

path

)

EnsureCacheDirectory()

bool cuttlefish::EnsureCacheDirectory

(

const std::string &

cache_base_path

)

EnsureDirectoryExists()

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

Enum2Base()

template<typename T >

constexpr std::underlying_type_t< T > cuttlefish::Enum2Base ( T  t )

constexpr

EnvpToMap()

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

(

char **

envp

)

ErrorFromType() [1/4]

auto cuttlefish::ErrorFromType ( bool  )

inline

ErrorFromType() [2/4]

template<typename T >

auto cuttlefish::ErrorFromType

(

Result< T > &&

value

)

ErrorFromType() [3/4]

template<typename T >

auto cuttlefish::ErrorFromType

(

Result< T > &

value

)

ErrorFromType() [4/4]

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/4]

int cuttlefish::Execute

(

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

commands

)

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/4]

int cuttlefish::Execute	(	const std::vector< std::string > &	commands,
		const std::vector< std::string > &	envs
	)

Execute() [3/4]

Result< siginfo_t > cuttlefish::Execute	(	const std::vector< std::string > &	commands,
		const std::vector< std::string > &	envs,
		SubprocessOptions	subprocess_options,
		int	wait_options
	)

Execute() [4/4]

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

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

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< cvd_common::Args > cuttlefish::ExtractCvdArgs

(

cvd_common::Args &

args

)

ExtractFile()

Result< void > cuttlefish::ExtractFile	(	ReadableZip &	zip,
		const std::string &	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

)

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< std::vector< FetchResult > > cuttlefish::FetchCvdMain

(

const FetchFlags &

flags

)

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
	)

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

)

FileInodeNumber()

Result< ino_t > cuttlefish::FileInodeNumber

(

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

)

FileOwnerUid()

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

static

FileSize()

off_t cuttlefish::FileSize

(

const std::string &

path

)

FinalizeTcti()

static void cuttlefish::FinalizeTcti ( TSS2_TCTI_CONTEXT *  tcti_context )

static

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
	)

FindImage()

std::string cuttlefish::FindImage	(	const std::string &	search_path,
		const std::vector< std::string > &	pattern
	)

Find an image file through the input path and pattern.

If it finds the file, return the path string. If it can't find the file, return empty string.

FindImageDir()

Result< std::string > cuttlefish::FindImageDir

(

const std::string &

image_dir

)

FindMiscInfo()

Result< std::string > cuttlefish::FindMiscInfo

(

const std::string &

image_dir

)

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

)

FromSeverity()

std::string cuttlefish::FromSeverity

(

const android::base::LogSeverity

severity

)

FuchsiaCompositeDiskConfig()

std::vector< ImagePartition > cuttlefish::FuchsiaCompositeDiskConfig

(

const CuttlefishConfig::InstanceSpecific &

instance

)

Gem5ImageUnpacker()

Result< void > cuttlefish::Gem5ImageUnpacker

(

const CuttlefishConfig &

config

)

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 std::uint8_t	mac[6],
		std::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

)

GenerateDisplayFlag()

Result< std::optional< std::string > > cuttlefish::GenerateDisplayFlag

(

const EnvironmentSpecification &

cfg

)

GenerateEthMacForInstance()

void cuttlefish::GenerateEthMacForInstance	(	int	index,
		std::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

)

GenerateMetricsFlags() [1/2]

std::vector< std::string > cuttlefish::GenerateMetricsFlags

(

const cvd::config::EnvironmentSpecification &

)

GenerateMetricsFlags() [2/2]

std::vector< std::string > cuttlefish::GenerateMetricsFlags

(

const EnvironmentSpecification &

config

)

GenerateMobileMacForInstance()

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

GenerateQueueKey()

key_t cuttlefish::GenerateQueueKey

(

const char *

str

)

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

)

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

)

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,
		std::uint8_t	out[6]
	)

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

)

GetBuildZipName()

std::string cuttlefish::GetBuildZipName	(	const Build &	build,
		const std::string &	name
	)

Returns the name of one of the artifact target zip files.

For example, for a target "aosp_cf_x86_phone-userdebug" at a build "5824130", the image zip file would be "aosp_cf_x86_phone-img-5824130.zip"

GetCacheSize()

Result< std::size_t > cuttlefish::GetCacheSize

(

const std::string &

cache_directory

)

GetCmdArgs()

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

(

const pid_t

pid

)

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

)

GetCredentialSource()

Result< std::unique_ptr< CredentialSource > > cuttlefish::GetCredentialSource	(	HttpClient &	http_client,
		const std::string &	credential_source,
		const std::string &	oauth_filepath,
		const bool	use_gce_metadata,
		const std::string &	credential_filepath,
		const std::string &	service_account_filepath
	)

GetCuttlefishConfigPath()

Result< std::string > cuttlefish::GetCuttlefishConfigPath

(

const std::string &

home

)

GetCvdFlags()

Result< CvdFlags > cuttlefish::GetCvdFlags

(

const LoadFlags &

flags

)

GetDefaultConfigFile()

Result< const std::string > cuttlefish::GetDefaultConfigFile

(

)

Return path to default config file.

GetDefaultVsockCid()

int cuttlefish::GetDefaultVsockCid

(

)

GetDiskUsageBytes()

Result< std::size_t > cuttlefish::GetDiskUsageBytes

(

const std::string &

path

)

GetDiskUsageGigabytes()

Result< std::size_t > cuttlefish::GetDiskUsageGigabytes

(

const std::string &

path

)

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

)

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

)

GetFlags()

Result< LoadFlags > cuttlefish::GetFlags	(	std::vector< std::string > &	args,
		const std::string &	working_directory
	)

GetGlobalConfigFileLink()

std::string cuttlefish::GetGlobalConfigFileLink

(

)

GetGraphicsAvailabilityWithSubprocessCheck()

gfxstream::proto::GraphicsAvailability cuttlefish::GetGraphicsAvailabilityWithSubprocessCheck

(

)

GetImageForPartition()

Result< std::string > cuttlefish::GetImageForPartition	(	std::string const &	partition_name,
		std::string const &	image_dir,
		const std::map< std::string, std::string > &	image_paths
	)

GetInstance()

int cuttlefish::GetInstance

(

)

GetLauncherMonitor()

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

GetLauncherMonitorFromInstance()

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

GetMinimumVerbosity()

android::base::LogSeverity cuttlefish::GetMinimumVerbosity

(

)

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
	)

GetPartitionGUID()

Result< const std::uint8_t * > cuttlefish::GetPartitionGUID

(

GptPartitionType

type

)

GetSeccompPolicyDir()

std::string cuttlefish::GetSeccompPolicyDir

(

)

GetUserIDFromSock()

uid_t cuttlefish::GetUserIDFromSock

(

SharedFD

client_socket

)

GetUserName()

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

(

uid_t

uid

)

GetUserType()

std::string cuttlefish::GetUserType

(

)

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< std::int32_t > > cuttlefish::GflagsBaseInstanceFlag ( )

static

GflagsCompatBoolFlagBase()

static Flag cuttlefish::GflagsCompatBoolFlagBase ( const std::string &  name )

static

GflagsCompatBoolFlagSetter()

static Result< void > cuttlefish::GflagsCompatBoolFlagSetter ( const std::string &  name, bool &  value, const FlagMatch &  match  )

static

GflagsCompatFlag() [1/11]

Flag cuttlefish::GflagsCompatFlag

(

const std::string &

name

)

GflagsCompatFlag() [2/11]

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

GflagsCompatFlag() [3/11]

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

GflagsCompatFlag() [4/11]

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

GflagsCompatFlag() [5/11]

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

GflagsCompatFlag() [6/11]

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

GflagsCompatFlag() [7/11]

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

GflagsCompatFlag() [8/11]

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

GflagsCompatFlag() [9/11]

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

GflagsCompatFlag() [10/11]

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

GflagsCompatFlag() [11/11]

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

GflagsCompatNumericFlagGeneric()

template<typename T >

static Flag cuttlefish::GflagsCompatNumericFlagGeneric ( const std::string &  name, T &  value  )

static

GflagsCompatUnsignedNumericFlagGeneric()

template<typename T >

static Flag cuttlefish::GflagsCompatUnsignedNumericFlagGeneric ( const std::string &  name, T &  value  )

static

GflagsComponent()

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

(

)

GflagsInstanceNumsFlag()

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

static

GflagsNumInstancesFlag()

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

static

GnssGrpcProxyBinary()

std::string cuttlefish::GnssGrpcProxyBinary

(

)

GnssGrpcProxyServer()

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

GpuMode()

std::string cuttlefish::GpuMode

(

const Instance &

instance

)

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

)

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

HardLinkDirecoryContentsRecursively()

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

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 &	value,
		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
	)

IfaceTyToStr()

std::string cuttlefish::IfaceTyToStr

(

IfaceType

iface

)

ImageFromFile()

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

(

const std::string &

file_path

)

ImportResourcesFromRunningServer()

void cuttlefish::ImportResourcesFromRunningServer

(

std::vector< std::string >

args

)

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 FetcherConfig &	fetcher_config,
		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
	)

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

InSandbox()

bool cuttlefish::InSandbox

(

)

InsName()

std::string cuttlefish::InsName

(

const Instance &

instance

)

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
	)

InstanceLocksPath()

std::string cuttlefish::InstanceLocksPath

(

)

InstanceNums()

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

static

INSTANTIATE_TEST_SUITE_P() [1/4]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	CommonUtilsTest	,
		EmulateAbsolutePathBase	,
		testing::Values(InputOutput{.path_to_convert_="/",.expected_="/"}, InputOutput{.path_to_convert_="",.expected_=""}, InputOutput{.path_to_convert_="/a/b/c/",.expected_="/a/b/c"}, InputOutput{.path_to_convert_="/a",.expected_="/a"})
	)

INSTANTIATE_TEST_SUITE_P() [2/4]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	CommonUtilsTest	,
		EmulateAbsolutePathWithHome	,
		testing::Values(InputOutput{.path_to_convert_="~",.home_dir_="/x/y/z",.expected_="/x/y/z"}, InputOutput{.path_to_convert_="~/a",.home_dir_="/x/y/z",.expected_="/x/y/z/a"}, InputOutput{.path_to_convert_="~/.",.home_dir_="/x/y/z",.expected_="/x/y/z"}, InputOutput{.path_to_convert_="~/..",.home_dir_="/x/y/z",.expected_="/x/y"}, InputOutput{.path_to_convert_="~/k/../../t/./q",.home_dir_="/x/y/z",.expected_="/x/y/t/q"})
	)

INSTANTIATE_TEST_SUITE_P() [3/4]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	CommonUtilsTest	,
		EmulateAbsolutePathWithPwd	,
		testing::Values(InputOutput{.path_to_convert_="",.working_dir_="/x/y/z",.expected_=""}, InputOutput{.path_to_convert_="a",.working_dir_="/x/y/z",.expected_="/x/y/z/a"}, InputOutput{.path_to_convert_=".",.working_dir_="/x/y/z",.expected_="/x/y/z"}, InputOutput{.path_to_convert_="..",.working_dir_="/x/y/z",.expected_="/x/y"}, InputOutput{.path_to_convert_="./k/../../t/./q",.working_dir_="/x/y/z",.expected_="/x/y/t/q"})
	)

INSTANTIATE_TEST_SUITE_P() [4/4]

cuttlefish::INSTANTIATE_TEST_SUITE_P	(	CvdIdAllocator	,
		OneEachTest	,
		testing::Values(std::vector< unsigned >{}, std::vector< unsigned >{1}, std::vector< unsigned >{1, 22, 3, 43, 5})
	)

InterfaceName()

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

static

InvalidFlagGuard()

Flag cuttlefish::InvalidFlagGuard

(

)

IptableConfig()

bool cuttlefish::IptableConfig	(	const std::string &	network,
		bool	add
	)

Ipv6ToString()

std::string cuttlefish::Ipv6ToString

(

const std::uint8_t

ip[16]

)

IsDirectory()

bool cuttlefish::IsDirectory ( const std::string &  path )

inline

IsDirectoryEmpty()

bool cuttlefish::IsDirectoryEmpty

(

const std::string &

path

)

IsHostCompatible()

bool cuttlefish::IsHostCompatible

(

Arch

arch

)

IsKernelModuleSigned() [1/2]

bool cuttlefish::IsKernelModuleSigned

(

const char *

path

)

IsKernelModuleSigned() [2/2]

constexpr bool cuttlefish::IsKernelModuleSigned ( const std::string &  path )

constexpr

IsRestoring()

bool cuttlefish::IsRestoring

(

const CuttlefishConfig &

config

)

IsRunningInContainer()

bool cuttlefish::IsRunningInContainer

(

)

IsRunningInDocker()

static bool cuttlefish::IsRunningInDocker ( )

static

IsServerModeExpected()

bool cuttlefish::IsServerModeExpected

(

const std::string &

exec_file

)

IsSparseImage()

Result< bool > cuttlefish::IsSparseImage

(

const std::string &

image_path

)

IsSubOperationSupported()

bool cuttlefish::IsSubOperationSupported

(

const CommandRequest &

request

)

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

)

IsValidMetricsConfigs()

bool cuttlefish::IsValidMetricsConfigs

(

int

value

)

JsIndexToLinux()

uint16_t cuttlefish::JsIndexToLinux

(

const int32_t &

index_code

)

KernelCommandLineFromConfig()

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

KernelLogMonitorBinary()

std::string cuttlefish::KernelLogMonitorBinary

(

)

KernelLogMonitorComponent()

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

(

)

KillAllCuttlefishInstances()

Result< void > cuttlefish::KillAllCuttlefishInstances

(

bool

clear_runtime_dirs

)

KillCvdServerProcess()

Result< void > cuttlefish::KillCvdServerProcess

(

)

Finds processes whose executable path is kServerExecPath, and that is owned by getuid(), and that has the "INTERNAL_server_fd" in the arguments list.

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

)

LaunchFastbootComponent()

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

(

)

launchStreamerComponent()

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

(

)

LikelyFlag()

static bool cuttlefish::LikelyFlag ( const std::string &  next_arg )

static

LinkTapToBridge()

bool cuttlefish::LinkTapToBridge	(	const std::string &	tap_name,
		const std::string &	bridge_name
	)

LinuxCompositeDiskConfig()

std::vector< ImagePartition > cuttlefish::LinuxCompositeDiskConfig

(

const CuttlefishConfig::InstanceSpecific &

instance

)

LoadAcloudConfig()

Result< AcloudConfig > cuttlefish::LoadAcloudConfig

(

const std::string &

user_config_path

)

LoadFromFile() [1/2]

Result< Json::Value > cuttlefish::LoadFromFile

(

const std::string &

path_to_file

)

LoadFromFile() [2/2]

Result< Json::Value > cuttlefish::LoadFromFile

(

SharedFD

json_fd

)

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

LogcatInfo()

std::string cuttlefish::LogcatInfo

(

const CuttlefishConfig::InstanceSpecific &

instance

)

LogcatReceiver()

Result< MonitorCommand > cuttlefish::LogcatReceiver

(

const CuttlefishConfig::InstanceSpecific &

instance

)

LogcatReceiverBinary()

std::string cuttlefish::LogcatReceiverBinary

(

)

LogFileSeverity()

android::base::LogSeverity cuttlefish::LogFileSeverity

(

)

LogToFiles()

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

LogToStderr()

TeeLogger cuttlefish::LogToStderr	(	const std::string &	log_prefix,
		MetadataLevel	stderr_level,
		std::optional< android::base::LogSeverity >	stderr_severity
	)

LogToStderrAndFiles()

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

MacAddressToString()

std::string cuttlefish::MacAddressToString

(

const std::uint8_t

mac[6]

)

main()

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

MakeAddress()

static void cuttlefish::MakeAddress ( const char *  name, bool  abstract, struct sockaddr_un *  dest, socklen_t *  len  )

static

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

(

)

MemoryMb()

static std::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

MetricsBinary()

std::string cuttlefish::MetricsBinary

(

)

MetricsService()

std::optional< MonitorCommand > cuttlefish::MetricsService

(

const CuttlefishConfig &

config

)

MkbootimgBinary()

std::string cuttlefish::MkbootimgBinary

(

)

MkenvimageSlimMain()

Result< int > 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	(	const std::string &	ipaddr,
		uint16_t	id
	)

MobileNetworkName()

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

ModemSimulator()

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

(

const CuttlefishConfig::InstanceSpecific &

instance

)

ModemSimulatorBinary()

std::string cuttlefish::ModemSimulatorBinary

(

)

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 > > cuttlefish::NetsimServerComponent

(

)

NetworkInterfaceExists()

bool cuttlefish::NetworkInterfaceExists

(

const std::string &

interface_name

)

NewAcloudCommand()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewAcloudCommand

(

CommandSequenceExecutor &

executor

)

NewAcloudMixSuperImageCommand()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewAcloudMixSuperImageCommand

(

)

NewAcloudTranslatorCommand()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewAcloudTranslatorCommand

(

InstanceManager &

instance_manager

)

NewCvdBugreportCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdBugreportCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdCacheCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdCacheCommandHandler

(

)

NewCvdClearCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdClearCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdCmdlistHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdCmdlistHandler

(

CommandSequenceExecutor &

executor

)

NewCvdCreateCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdCreateCommandHandler	(	InstanceManager &	instance_manager,
		CommandSequenceExecutor &	executor,
		InstanceLockFileManager &	lock_manager
	)

NewCvdDevicePowerBtnCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdDevicePowerBtnCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdDevicePowerwashCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdDevicePowerwashCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdDeviceRestartCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdDeviceRestartCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdDisplayCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdDisplayCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdEnvCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdEnvCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdFetchCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdFetchCommandHandler

(

)

NewCvdFleetCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdFleetCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdHelpHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdHelpHandler

(

const std::vector< std::unique_ptr< CvdCommandHandler > > &

server_handlers

)

NewCvdNoopHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdNoopHandler

(

)

NewCvdResetCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdResetCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdSnapshotCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdSnapshotCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdStartCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdStartCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdStatusCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdStatusCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdStopCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdStopCommandHandler

(

InstanceManager &

instance_manager

)

NewCvdVersionHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewCvdVersionHandler

(

)

NewfsMsdos()

std::string cuttlefish::NewfsMsdos

(

)

NewLintCommand()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewLintCommand

(

)

NewLoadConfigsCommand()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewLoadConfigsCommand	(	CommandSequenceExecutor &	executor,
		InstanceManager &	instance_manager
	)

NewLoginCommand()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewLoginCommand

(

)

Create a credentials file

NewRemoveCvdCommandHandler()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewRemoveCvdCommandHandler

(

InstanceManager &

instance_manager

)

NewTryAcloudCommand()

std::unique_ptr< CvdCommandHandler > cuttlefish::NewTryAcloudCommand

(

)

next_tombstone_path()

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

static

NfcConnector()

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

NoGroupMessage()

std::string cuttlefish::NoGroupMessage

(

const CommandRequest &

request

)

NumberOfOccurrences()

int cuttlefish::NumberOfOccurrences	(	const std::string &	str,
		const std::string &	substr
	)

Oauth2LoginLocal()

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

Oauth2LoginSsh()

Result< std::unique_ptr< CredentialSource > > cuttlefish::Oauth2LoginSsh	(	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 > > 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/2]

bool cuttlefish::operator!=	(	const DeviceBuildString &	lhs,
		const DeviceBuildString &	rhs
	)

operator!=() [2/2]

bool cuttlefish::operator!=	(	const DirectoryBuildString &	lhs,
		const DirectoryBuildString &	rhs
	)

operator<<() [1/22]

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

operator<<() [2/22]

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

operator<<() [3/22]

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

operator<<() [4/22]

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

operator<<() [5/22]

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

operator<<() [6/22]

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

operator<<() [7/22]

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

operator<<() [8/22]

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

operator<<() [9/22]

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

operator<<() [10/22]

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

operator<<() [11/22]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const FlagAlias &	alias
	)

operator<<() [12/22]

std::ostream & cuttlefish::operator<<	(	std::ostream &	out,
		const Override &	override
	)

operator<<() [13/22]

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

operator<<() [14/22]

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

operator<<() [15/22]

template<typename T >

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

operator<<() [16/22]

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

operator<<() [17/22]

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

operator<<() [18/22]

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

operator<<() [19/22]

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

operator<<() [20/22]

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

operator<<() [21/22]

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

operator<<() [22/22]

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

operator==() [1/2]

bool cuttlefish::operator==	(	const DeviceBuildString &	lhs,
		const DeviceBuildString &	rhs
	)

operator==() [2/2]

bool cuttlefish::operator==	(	const DirectoryBuildString &	lhs,
		const DirectoryBuildString &	rhs
	)

OsCompositeDiskBuilder()

DiskBuilder cuttlefish::OsCompositeDiskBuilder	(	const CuttlefishConfig &	config,
		const CuttlefishConfig::InstanceSpecific &	instance,
		const std::optional< ChromeOsStateImage > &	chrome_os_state,
		const MetadataImage &	metadata,
		const MiscImage &	misc,
		const SystemImageDirFlag &	system_image_dir
	)

OutcomeDereference() [1/3]

template<typename T >

std::conditional_t< std::is_void_v< T >, bool, T > cuttlefish::OutcomeDereference

(

Result< T > &&

result

)

OutcomeDereference() [2/3]

template<typename T >

T cuttlefish::OutcomeDereference

(

std::optional< T > &&

value

)

OutcomeDereference() [3/3]

template<typename T >

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

(

T &&

value

)

Overload()

template<typename... Ts>

cuttlefish::Overload

(

Ts...

)

-> Overload< Ts... >

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()

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

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

ParseBaseInstanceFlag()

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

static

ParseBool()

Result< bool > cuttlefish::ParseBool	(	const std::string &	value,
		const std::string &	name
	)

ParseBuildString()

Result< BuildString > cuttlefish::ParseBuildString

(

const std::string &

build_string

)

ParseChromeOsBuildString()

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

static

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
	)

ParseGuestHwuiRenderer()

Result< GuestHwuiRenderer > cuttlefish::ParseGuestHwuiRenderer

(

std::string_view

str

)

ParseGuestRendererPreload()

Result< GuestRendererPreload > cuttlefish::ParseGuestRendererPreload

(

std::string_view

str

)

ParseInstanceNums()

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

static

ParseInstanceNumsFlag()

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

static

ParseInteger()

template<typename T >

std::optional< T > cuttlefish::ParseInteger

(

const std::string &

value

)

ParseJson()

Result< Json::Value > cuttlefish::ParseJson

(

std::string_view

input

)

ParseJsonString()

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

ParseKeyEqualsValue()

Result< std::map< std::string, std::string > > 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

)

ParseMatchedLine()

static Result< TypeAndId > cuttlefish::ParseMatchedLine ( const std::smatch &  device_string_match )

static

ParseNumInstancesFlag()

static Result< std::optional< std::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]

std::vector< std::string > cuttlefish::ParseSelectorConfigs

(

const cvd::config::EnvironmentSpecification &

)

ParseSelectorConfigs() [2/2]

std::vector< std::string > cuttlefish::ParseSelectorConfigs

(

const EnvironmentSpecification &

config

)

ParseTextProtoConfigHelper()

template<typename ProtoType >

Result< ProtoType > cuttlefish::ParseTextProtoConfigHelper

(

const std::string &

config_path

)

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

)

PerUserCacheDir()

std::string cuttlefish::PerUserCacheDir

(

)

PerUserDir()

std::string cuttlefish::PerUserDir

(

)

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

Ppid()

Result< pid_t > cuttlefish::Ppid

(

const pid_t

pid

)

PrepareESP()

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

PrepareForAcloudDeleteCommand()

Result< void > cuttlefish::PrepareForAcloudDeleteCommand

(

const std::string &

host_artifacts

)

PrintDataCollectionNotice()

void cuttlefish::PrintDataCollectionNotice

(

bool

colorful = true

)

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.

ProtoToString()

std::string cuttlefish::ProtoToString

(

LogEvent *

event

)

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 std::size_t	allowed_size_gb
	)

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.

RandomSerialNumber()

std::string cuttlefish::RandomSerialNumber

(

const std::string &

prefix

)

ReadAll() [1/2]

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

static

ReadAll() [2/2]

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

Reads from fd until it is closed or errors, storing all data in buf.

On a successful read, returns the number of bytes read.

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

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/3]

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() [2/3]

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() [3/3]

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()

template<typename T >

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

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 &

filepath

)

ReadGuestConfig()

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

ReadLauncherActionFromFd()

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

(

SharedFD

monitor_socket

)

ReadProtectedJsonFromFile()

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

ReadToString() [1/2]

Result< std::string > cuttlefish::ReadToString

(

ReadableZipSource &

source

)

ReadToString() [2/2]

Result< std::string > cuttlefish::ReadToString

(

ZipSourceReader &

reader

)

RebuildSuperImageIfNecessary()

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

RecordScreen()

bool cuttlefish::RecordScreen

(

const Instance &

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()

std::string cuttlefish::RecvAll	(	SharedFD	sock,
		size_t	count
	)

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

On successful Recv, returns a string containing the received data

If a Recv error is encountered, returns the empty string

RecvJsonMsg()

std::optional< Json::Value > cuttlefish::RecvJsonMsg

(

cuttlefish::SharedFD

client_socket

)

Receives a single Json value over client_socket

The returned option will contain the JSON object when successful, or an std::nullopt if an error is reported

RemoveFile()

bool cuttlefish::RemoveFile

(

const std::string &

file

)

RenameFile()

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

RepackBootImage()

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

RepackGem5BootImage()

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,
		const Avb &	avb
	)

RepackSuperWithPartition()

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

RepackVendorBootImage()

bool 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()

bool 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
	)

ReqTyToStr()

std::string cuttlefish::ReqTyToStr

(

RequestType

req_ty

)

RequestHandler()

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

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
	)

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

(

)

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
	)

RunWithManagedStdio()

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

sampleEvent()

CuttlefishLogEvent * cuttlefish::sampleEvent

(

)

ScreenRecordingServer()

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

(

GrpcSocketCreator &

grpc_socket

)

ScreenRecordingServerBinary()

std::string cuttlefish::ScreenRecordingServerBinary

(

)

ScrubSecrets()

std::string cuttlefish::ScrubSecrets

(

const std::string &

data

)

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.

SendHelper()

void cuttlefish::SendHelper	(	const std::string &	queue_name,
		const std::string &	message
	)

SendJsonMsg()

bool cuttlefish::SendJsonMsg	(	cuttlefish::SharedFD	client_socket,
		const Json::Value &	resp
	)

Sends a Json value over client_socket

returns true if successfully sent the whole JSON object returns false otherwise

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

(

)

SeparateByEndOfOptionMark()

static Separated cuttlefish::SeparateByEndOfOptionMark ( std::vector< std::string >  args )

static

SerializableToKeyBlob()

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

static

Serialize()

std::string cuttlefish::Serialize

(

const DisjointRangeSet &

range_set

)

SerializeKeyEqualsValue()

std::string cuttlefish::SerializeKeyEqualsValue

(

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

key_equals_value

)

serverLoopComponent()

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

(

)

ServerSocketPath()

std::string cuttlefish::ServerSocketPath

(

)

Set()

static Result< void > cuttlefish::Set ( const FlagMatch &  match, SharedFD &  out  )

static

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
	)

SetMinimumVerbosity() [1/2]

android::base::LogSeverity cuttlefish::SetMinimumVerbosity

(

const android::base::LogSeverity

severity

)

SetMinimumVerbosity() [2/2]

Result< android::base::LogSeverity > cuttlefish::SetMinimumVerbosity

(

const std::string &

severity

)

SetupBridgeGateway()

bool cuttlefish::SetupBridgeGateway	(	const std::string &	bridge_name,
		const std::string &	ipaddr
	)

SetupFeatureDeps()

template<typename... Args>

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

(

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

args

)

SetupWizardMode()

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

static

SeverityTargetsForFiles()

static std::vector< SeverityTarget > cuttlefish::SeverityTargetsForFiles ( const std::vector< std::string > &  files )

static

SharedFDFlag() [1/2]

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

SharedFDFlag() [2/2]

Flag cuttlefish::SharedFDFlag

(

SharedFD &

out

)

ShutdownIface()

bool cuttlefish::ShutdownIface

(

const std::string &

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

(

)

SparseFileSizes()

FileSizes cuttlefish::SparseFileSizes

(

const std::string &

path

)

SplitByLines()

template<typename F , typename... Args>

static void cuttlefish::SplitByLines ( const char *  msg, const F &  log_function, Args &&...  args  )

static

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()

bool 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	(	const std::string &	bridge_name,
		const std::string &	gateway,
		const std::string &	dhcp_range
	)

StatusToStr()

std::string cuttlefish::StatusToStr

(

RequestStatus

st

)

StderrOutputGenerator() [1/2]

std::string cuttlefish::StderrOutputGenerator	(	const struct tm &	now,
		int	pid,
		uint64_t	tid,
		android::base::LogSeverity	severity,
		const char *	tag,
		const char *	file,
		unsigned int	line,
		const char *	message
	)

StderrOutputGenerator() [2/2]

std::string cuttlefish::StderrOutputGenerator	(	const struct tm &	now,
		int	pid,
		uint64_t	tid,
		LogSeverity	severity,
		const char *	tag,
		const char *	file,
		unsigned int	line,
		const char *	message
	)

StopCvdBinary()

std::string cuttlefish::StopCvdBinary

(

)

StopDnsmasq()

bool cuttlefish::StopDnsmasq

(

const std::string &

name

)

StopModemSimulator()

static StopperResult cuttlefish::StopModemSimulator ( int  id )

static

StorageDataToRecord()

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

static

StringFromEnv() [1/2]

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

(

const std::string &

varname

)

StringFromEnv() [2/2]

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

StringToAdbMode()

AdbMode cuttlefish::StringToAdbMode

(

const std::string &

mode

)

StripColorCodes()

std::string cuttlefish::StripColorCodes

(

const std::string &

str

)

StrToIfaceTy()

IfaceType cuttlefish::StrToIfaceTy

(

const std::string &

iface

)

StrToReqTy()

RequestType cuttlefish::StrToReqTy

(

const std::string &

req

)

StrToStatus()

RequestStatus cuttlefish::StrToStatus

(

const std::string &

st

)

SuperImageNeedsRebuilding()

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

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())

TcpConnectorBinary()

std::string cuttlefish::TcpConnectorBinary

(

)

TempDir()

std::string cuttlefish::TempDir

(

)

TEST() [1/202]

cuttlefish::TEST	(	AdbConfigTest	,
		SerializeDeserialize
	)

TEST() [2/202]

cuttlefish::TEST	(	AdbConfigTest	,
		SetFromFlags
	)

TEST() [3/202]

cuttlefish::TEST	(	Base64Test	,
		DecodeMult3
	)

TEST() [4/202]

cuttlefish::TEST	(	Base64Test	,
		DecodeNonMult3
	)

TEST() [5/202]

cuttlefish::TEST	(	Base64Test	,
		EncodeMult3
	)

TEST() [6/202]

cuttlefish::TEST	(	Base64Test	,
		EncodeNonMult3
	)

TEST() [7/202]

cuttlefish::TEST	(	Base64Test	,
		EncodeOneZero
	)

TEST() [8/202]

cuttlefish::TEST	(	Base64Test	,
		EncodeThreeZeroes
	)

TEST() [9/202]

cuttlefish::TEST	(	Base64Test	,
		EncodeTwoZeroes
	)

TEST() [10/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseNetSimFlagEmptyJson
	)

TEST() [11/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseNetSimFlagEnabled
	)

TEST() [12/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesAutoTabletDisplaysFlag
	)

TEST() [13/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBlankDataImageEmptyJson
	)

TEST() [14/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBlankDataImageFullJson
	)

TEST() [15/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBlankDataImagePartialJson
	)

TEST() [16/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBootAnimationFlagEmptyJson
	)

TEST() [17/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBootAnimationFlagFullJson
	)

TEST() [18/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesBootAnimationFlagPartialJson
	)

TEST() [19/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesDisplaysFlagEmptyDisplays
	)

TEST() [20/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesDisplaysFlagEmptyGraphics
	)

TEST() [21/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesDisplaysFlagEmptyJson
	)

TEST() [22/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesEnforceSecurityFlagEmptyJson
	)

TEST() [23/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesEnforceSecurityFlagFullJson
	)

TEST() [24/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesEnforceSecurityFlagPartialJson
	)

TEST() [25/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesSerialNumberFlagEmptyJson
	)

TEST() [26/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesSerialNumberFlagFullJson
	)

TEST() [27/202]

cuttlefish::TEST	(	BootFlagsParserTest	,
		ParseTwoInstancesSerialNumberFlagPartialJson
	)

TEST() [28/202]

cuttlefish::TEST	(	BuildStringGflagsCompatFlagTests	,
		EmptyInputEmptyResultSuccess
	)

TEST() [29/202]

cuttlefish::TEST	(	BuildStringGflagsCompatFlagTests	,
		MultiEmptyValueSuccess
	)

TEST() [30/202]

cuttlefish::TEST	(	BuildStringGflagsCompatFlagTests	,
		MultiValueMixedWithEmptySuccess
	)

TEST() [31/202]

cuttlefish::TEST	(	BuildStringGflagsCompatFlagTests	,
		MultiValueSuccess
	)

TEST() [32/202]

cuttlefish::TEST	(	CvdAutoGenId	,
		CvdTwoFollowedByFive
	)

TEST() [33/202]

cuttlefish::TEST	(	CvdBasic	,
		CvdDefaultStart
	)

TEST() [34/202]

cuttlefish::TEST	(	CvdClear	,
		ClearAfterThreeStarts
	)

TEST() [35/202]

cuttlefish::TEST	(	CvdDriver	,
		CvdHelp
	)

TEST() [36/202]

cuttlefish::TEST	(	CvdDriver	,
		CvdHelpWrong
	)

TEST() [37/202]

cuttlefish::TEST	(	CvdDriver	,
		CvdOnly
	)

TEST() [38/202]

cuttlefish::TEST	(	CvdFlagTest	,
		FlagProxyFilter
	)

TEST() [39/202]

cuttlefish::TEST	(	CvdHelpFlagCollect	,
		LauncCvd
	)

TEST() [40/202]

cuttlefish::TEST	(	CvdIdAllocatorExpandTest	,
		Expand
	)

TEST() [41/202]

cuttlefish::TEST	(	CvdInstanceIds	,
		CvdTakenInstanceIds
	)

TEST() [42/202]

cuttlefish::TEST	(	CvdSubtool	,
		CvdStartHelp
	)

TEST() [43/202]

cuttlefish::TEST	(	CvdSubtool	,
		CvdStopHelp
	)

TEST() [44/202]

cuttlefish::TEST	(	DisplayConfigTest	,
		ParseProto
	)

TEST() [45/202]

cuttlefish::TEST	(	FakeHttpClientTest	,
		ChoosesUrl
	)

TEST() [46/202]

cuttlefish::TEST	(	FakeHttpClientTest	,
		InvokesCallback
	)

TEST() [47/202]

cuttlefish::TEST	(	FakeHttpClientTest	,
		NoMatchingUrl
	)

TEST() [48/202]

cuttlefish::TEST	(	FakeHttpClientTest	,
		WithoutUrlMatching
	)

TEST() [49/202]

cuttlefish::TEST	(	FetchCvdParserTests	,
		CreatesCasDownloaderFlags
	)

TEST() [50/202]

cuttlefish::TEST	(	FlagParser	,
		BoolFlag
	)

TEST() [51/202]

cuttlefish::TEST	(	FlagParser	,
		BoolFlagXml
	)

TEST() [52/202]

cuttlefish::TEST	(	FlagParser	,
		BoolVectorFlag
	)

TEST() [53/202]

cuttlefish::TEST	(	FlagParser	,
		ConflictingAlias
	)

TEST() [54/202]

cuttlefish::TEST	(	FlagParser	,
		ConsumesConstrainedEquals
	)

TEST() [55/202]

cuttlefish::TEST	(	FlagParser	,
		ConsumesConstrainedSeparated
	)

TEST() [56/202]

cuttlefish::TEST	(	FlagParser	,
		DuplicateAlias
	)

TEST() [57/202]

cuttlefish::TEST	(	FlagParser	,
		EndOfOptionMark
	)

TEST() [58/202]

cuttlefish::TEST	(	FlagParser	,
		FlagRemoval
	)

TEST() [59/202]

cuttlefish::TEST	(	FlagParser	,
		GflagsIncompatibleFlag
	)

TEST() [60/202]

cuttlefish::TEST	(	FlagParser	,
		IntFlag
	)

TEST() [61/202]

cuttlefish::TEST	(	FlagParser	,
		IntFlagXml
	)

TEST() [62/202]

cuttlefish::TEST	(	FlagParser	,
		InvalidFlagGuard
	)

TEST() [63/202]

cuttlefish::TEST	(	FlagParser	,
		InvalidIntFlag
	)

TEST() [64/202]

cuttlefish::TEST	(	FlagParser	,
		InvalidStringFlag
	)

TEST() [65/202]

cuttlefish::TEST	(	FlagParser	,
		InvalidVerbosityFlag
	)

TEST() [66/202]

cuttlefish::TEST	(	FlagParser	,
		NormalizedStringFlag
	)

TEST() [67/202]

cuttlefish::TEST	(	FlagParser	,
		RepeatedListFlag
	)

TEST() [68/202]

cuttlefish::TEST	(	FlagParser	,
		RepeatedStringFlag
	)

TEST() [69/202]

cuttlefish::TEST	(	FlagParser	,
		StringFlag
	)

TEST() [70/202]

cuttlefish::TEST	(	FlagParser	,
		StringFlagXml
	)

TEST() [71/202]

cuttlefish::TEST	(	FlagParser	,
		StringIntFlag
	)

TEST() [72/202]

cuttlefish::TEST	(	FlagParser	,
		StringVectorFlag
	)

TEST() [73/202]

cuttlefish::TEST	(	FlagParser	,
		UnexpectedArgumentGuard
	)

TEST() [74/202]

cuttlefish::TEST	(	FlagParser	,
		VerbosityFlag
	)

TEST() [75/202]

cuttlefish::TEST	(	FlagsInheritanceTest	,
		MergeTwoIndependentJson
	)

TEST() [76/202]

cuttlefish::TEST	(	FlagsInheritanceTest	,
		MergeTwoOverlappedJson
	)

TEST() [77/202]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseBasicJsonSingleInstances
	)

TEST() [78/202]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseBasicJsonTwoInstances
	)

TEST() [79/202]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseInvalidJson
	)

TEST() [80/202]

cuttlefish::TEST	(	FlagsParserTest	,
		ParseJsonWithSpellingError
	)

TEST() [81/202]

cuttlefish::TEST	(	FrontlineParserTest	,
		SelectorArgs
	)

TEST() [82/202]

cuttlefish::TEST	(	GpxParser	,
		ParseEmptyFile
	)

TEST() [83/202]

cuttlefish::TEST	(	GpxParser	,
		ParseEmptyRteTrkFile
	)

TEST() [84/202]

cuttlefish::TEST	(	GpxParser	,
		ParseEmptyRteTrkString
	)

TEST() [85/202]

cuttlefish::TEST	(	GpxParser	,
		ParseEmptyString
	)

TEST() [86/202]

cuttlefish::TEST	(	GpxParser	,
		ParseFileNotFound
	)

TEST() [87/202]

cuttlefish::TEST	(	GpxParser	,
		ParseFileNullAttributeFile
	)

TEST() [88/202]

cuttlefish::TEST	(	GpxParser	,
		ParseFileNullAttributeString
	)

TEST() [89/202]

cuttlefish::TEST	(	GpxParser	,
		ParseLocationMissingLatitudeFile
	)

TEST() [90/202]

cuttlefish::TEST	(	GpxParser	,
		ParseLocationMissingLatitudeString
	)

TEST() [91/202]

cuttlefish::TEST	(	GpxParser	,
		ParseLocationMissingLongitudeFile
	)

TEST() [92/202]

cuttlefish::TEST	(	GpxParser	,
		ParseLocationMissingLongitudeString
	)

TEST() [93/202]

cuttlefish::TEST	(	GpxParser	,
		ParseValidDocumentFile
	)

TEST() [94/202]

cuttlefish::TEST	(	GpxParser	,
		ParseValidDocumentString
	)

TEST() [95/202]

cuttlefish::TEST	(	GpxParser	,
		ParseValidFile
	)

TEST() [96/202]

cuttlefish::TEST	(	GpxParser	,
		ParseValidLocationFile
	)

TEST() [97/202]

cuttlefish::TEST	(	GpxParser	,
		ParseValidLocationString
	)

TEST() [98/202]

cuttlefish::TEST	(	GpxParser	,
		ParseValidString
	)

TEST() [99/202]

cuttlefish::TEST	(	HostToolManager	,
		KnownBins
	)

TEST() [100/202]

cuttlefish::TEST	(	HostToolTarget	,
		KnownFlags
	)

TEST() [101/202]

cuttlefish::TEST	(	KmlParser	,
		ParseBadCoordinatesFile
	)

TEST() [102/202]

cuttlefish::TEST	(	KmlParser	,
		ParseBadCoordinatesString
	)

TEST() [103/202]

cuttlefish::TEST	(	KmlParser	,
		ParseEmptyKmlFile
	)

TEST() [104/202]

cuttlefish::TEST	(	KmlParser	,
		ParseEmptyKmlString
	)

TEST() [105/202]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationMissingRequiredFieldsFile
	)

TEST() [106/202]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationMissingRequiredFieldsString
	)

TEST() [107/202]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNameOnlyFirstFile
	)

TEST() [108/202]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNameOnlyFirstString
	)

TEST() [109/202]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNormalFile
	)

TEST() [110/202]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNormalMissingOptionalFieldsFile
	)

TEST() [111/202]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNormalMissingOptionalFieldsString
	)

TEST() [112/202]

cuttlefish::TEST	(	KmlParser	,
		ParseLocationNormalString
	)

TEST() [113/202]

cuttlefish::TEST	(	KmlParser	,
		ParseMultipleCoordinatesFile
	)

TEST() [114/202]

cuttlefish::TEST	(	KmlParser	,
		ParseMultipleCoordinatesString
	)

TEST() [115/202]

cuttlefish::TEST	(	KmlParser	,
		ParseMultipleLocationsFile
	)

TEST() [116/202]

cuttlefish::TEST	(	KmlParser	,
		ParseMultipleLocationsString
	)

TEST() [117/202]

cuttlefish::TEST	(	KmlParser	,
		ParseNonexistentFile
	)

TEST() [118/202]

cuttlefish::TEST	(	KmlParser	,
		ParseOneCoordinateFile
	)

TEST() [119/202]

cuttlefish::TEST	(	KmlParser	,
		ParseOneCoordinateString
	)

TEST() [120/202]

cuttlefish::TEST	(	KmlParser	,
		ParsePlacemarkNullNameNoCrashFile
	)

TEST() [121/202]

cuttlefish::TEST	(	KmlParser	,
		ParsePlacemarkNullNameNoCrashString
	)

TEST() [122/202]

cuttlefish::TEST	(	KmlParser	,
		ParseValidComplexFile
	)

TEST() [123/202]

cuttlefish::TEST	(	KmlParser	,
		ParseValidComplexString
	)

TEST() [124/202]

cuttlefish::TEST	(	KmlParser	,
		ParseValidKmlFile
	)

TEST() [125/202]

cuttlefish::TEST	(	KmlParser	,
		ParseValidKmlString
	)

TEST() [126/202]

cuttlefish::TEST	(	KmlParser	,
		TraverseDocNoPlacemarksFile
	)

TEST() [127/202]

cuttlefish::TEST	(	KmlParser	,
		TraverseDocNoPlacemarksString
	)

TEST() [128/202]

cuttlefish::TEST	(	KmlParser	,
		TraverseEmptyDocFile
	)

TEST() [129/202]

cuttlefish::TEST	(	KmlParser	,
		TraverseEmptyDocString
	)

TEST() [130/202]

cuttlefish::TEST	(	KmlParser	,
		TraverseNestedDocFile
	)

TEST() [131/202]

cuttlefish::TEST	(	KmlParser	,
		TraverseNestedDocString
	)

TEST() [132/202]

cuttlefish::TEST	(	MacAddressTest	,
		MacAddressFormat
	)

TEST() [133/202]

cuttlefish::TEST	(	MacAddressTest	,
		ValidMacAddress
	)

TEST() [134/202]

cuttlefish::TEST	(	MetricsFlagsParserTest	,
		ParseOneInstanceMetricsReportInvalidValue
	)

TEST() [135/202]

cuttlefish::TEST	(	MetricsFlagsParserTest	,
		ParseOneInstanceMetricsReportValidValue
	)

TEST() [136/202]

cuttlefish::TEST	(	MetricsFlagsParserTest	,
		ParseOneInstancesMetricsReportFlagEmptyJson
	)

TEST() [137/202]

cuttlefish::TEST	(	MetricsFlagsParserTest	,
		ParseTwoInstancesMetricsReportFlagEmptyJson
	)

TEST() [138/202]

cuttlefish::TEST	(	ParseBuildStringTests	,
		DeviceBuildStringMultipleSlashesFail
	)

TEST() [139/202]

cuttlefish::TEST	(	ParseBuildStringTests	,
		DeviceBuildStringNoTargetSuccess
	)

TEST() [140/202]

cuttlefish::TEST	(	ParseBuildStringTests	,
		DeviceBuildStringSuccess
	)

TEST() [141/202]

cuttlefish::TEST	(	ParseBuildStringTests	,
		DirectoryBuildStringMultiplePathSuccess
	)

TEST() [142/202]

cuttlefish::TEST	(	ParseBuildStringTests	,
		DirectoryBuildStringSinglePathSuccess
	)

TEST() [143/202]

cuttlefish::TEST	(	ParseBuildStringTests	,
		EmptyStringFail
	)

TEST() [144/202]

cuttlefish::TEST	(	ParseBuildStringTests	,
		FilepathBracketsButNoValueFail
	)

TEST() [145/202]

cuttlefish::TEST	(	ParseBuildStringTests	,
		FilepathExistsMissingBracketFail
	)

TEST() [146/202]

cuttlefish::TEST	(	ParseBuildStringTests	,
		FilepathExistsSuccess
	)

TEST() [147/202]

cuttlefish::TEST	(	ParseBuildStringTests	,
		FilepathOnlyFail
	)

TEST() [148/202]

cuttlefish::TEST	(	ProcFilePid	,
		CurrentPidCollected
	)

TEST() [149/202]

cuttlefish::TEST	(	ProcFileUid	,
		SelfUidTest
	)

TEST() [150/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectBoolBadNoMessage
	)

TEST() [151/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectBoolBadWithMessage
	)

TEST() [152/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectBoolGoodNoMessage
	)

TEST() [153/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectBoolGoodWithMessage
	)

TEST() [154/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectEqBadNoMessage
	)

TEST() [155/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectEqBadWithMessage
	)

TEST() [156/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectEqGoodNoMessage
	)

TEST() [157/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectEqGoodWithMessage
	)

TEST() [158/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectWithResultBadNoMessage
	)

TEST() [159/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectWithResultBadWithMessage
	)

TEST() [160/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectWithResultGoodNoMessage
	)

TEST() [161/202]

cuttlefish::TEST	(	ResultTest	,
		ExpectWithResultGoodWithMessage
	)

TEST() [162/202]

cuttlefish::TEST	(	SendFD	,
		Basic
	)

TEST() [163/202]

cuttlefish::TEST	(	SingleBuildStringGflagsCompatFlagTests	,
		EmptyInputEmptyResultSuccess
	)

TEST() [164/202]

cuttlefish::TEST	(	SingleBuildStringGflagsCompatFlagTests	,
		HasValueSuccess
	)

TEST() [165/202]

cuttlefish::TEST	(	TpmEncryptedSerializable	,
		BinaryData
	)

TEST() [166/202]

cuttlefish::TEST	(	UnixMessageSocket	,
		AutoCredentials
	)

TEST() [167/202]

cuttlefish::TEST	(	UnixMessageSocket	,
		BadCredentialsBlocked
	)

TEST() [168/202]

cuttlefish::TEST	(	UnixMessageSocket	,
		SendCredentials
	)

TEST() [169/202]

cuttlefish::TEST	(	UnixMessageSocket	,
		SendFileDescriptor
	)

TEST() [170/202]

cuttlefish::TEST	(	UnixMessageSocket	,
		SendPlainMessage
	)

TEST() [171/202]

cuttlefish::TEST	(	UnixMessageSocket	,
		SendTwoFileDescriptors
	)

TEST() [172/202]

cuttlefish::TEST	(	UnixSocketMessage	,
		ExtractFileDescriptors
	)

TEST() [173/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseOneInstanceSetupWizardInvalidValue
	)

TEST() [174/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesCpuFlagEmptyJson
	)

TEST() [175/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesCpuFlagFullJson
	)

TEST() [176/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesCpuFlagPartialJson
	)

TEST() [177/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesCustomActionsFlagEmptyJson
	)

TEST() [178/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesCustomActionsFlagPartialJson
	)

TEST() [179/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesMemoryFlagEmptyJson
	)

TEST() [180/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesMemoryFlagFullJson
	)

TEST() [181/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesMemoryFlagPartialJson
	)

TEST() [182/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesQemu
	)

TEST() [183/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSandboxFlagEmptyJson
	)

TEST() [184/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSandboxFlagFullJson
	)

TEST() [185/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSandboxFlagPartialJson
	)

TEST() [186/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSdCardFlagEmptyJson
	)

TEST() [187/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSdCardFlagFullJson
	)

TEST() [188/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSdCardFlagPartialJson
	)

TEST() [189/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSetupWizardFlagEmptyJson
	)

TEST() [190/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSetupWizardFlagFullJson
	)

TEST() [191/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSetupWizardFlagPartialJson
	)

TEST() [192/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSimpleMediaDeviceFlagEmptyJson
	)

TEST() [193/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSimpleMediaDeviceFlagFullJson
	)

TEST() [194/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesSimpleMediaDeviceFlagPartialJson
	)

TEST() [195/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesUuidFlagEmptyJson
	)

TEST() [196/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesUuidFlagFullJson
	)

TEST() [197/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesUuidFlagPartialJson
	)

TEST() [198/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesV4l2ProxyFlagEmptyJson
	)

TEST() [199/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesV4l2ProxyFlagFullJson
	)

TEST() [200/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesV4l2ProxyFlagPartialJson
	)

TEST() [201/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesVmManagerFlagDefault
	)

TEST() [202/202]

cuttlefish::TEST	(	VmFlagsParserTest	,
		ParseTwoInstancesVmManagerFlagEmptyJson
	)

TEST_F() [1/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		CacheEnabledIfCacheDirSet
	)

TEST_F() [2/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		DisablesCacheIfCacheDirNotSet
	)

TEST_F() [3/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		DownloadsCompressedIfNotPreferUncompressed
	)

TEST_F() [4/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		DownloadsCompressedIfPreferUncompressedButUnavailable
	)

TEST_F() [5/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		DownloadsDigestsOnlyIfNeeded
	)

TEST_F() [6/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		DownloadsUncompressedIfPreferUncompressed
	)

TEST_F() [7/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		FailsIfArtifactNotInDigestsFile
	)

TEST_F() [8/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		FailsIfDigestsFileDoesNotExist
	)

TEST_F() [9/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		FailsToCreateWithInvalidCasDownloaderPath
	)

TEST_F() [10/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		FailsToCreateWithInvalidConfigPath
	)

TEST_F() [11/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		HandlesFalseBoolFlag
	)

TEST_F() [12/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		HandlesUnexpectedHelpOutput
	)

TEST_F() [13/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		IgnoresUnsupportedFlags
	)

TEST_F() [14/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		PassesCasOptionsFromCommandLine
	)

TEST_F() [15/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		PassesOptionalStatsFilepathWhenSet
	)

TEST_F() [16/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		RecognizesValidFlags
	)

TEST_F() [17/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		UsesAdcIfServiceAccountUnavailable
	)

TEST_F() [18/41]

cuttlefish::TEST_F	(	CasDownloaderTests	,
		UsesServiceAccountIfAvailable
	)

TEST_F() [19/41]

cuttlefish::TEST_F	(	CvdFlagCollectionTest	,
		AllGivenFlagsListed
	)

TEST_F() [20/41]

cuttlefish::TEST_F	(	CvdFlagCollectionTest	,
		Init
	)

TEST_F() [21/41]

cuttlefish::TEST_F	(	CvdFlagCollectionTest	,
		Leftover
	)

TEST_F() [22/41]

cuttlefish::TEST_F	(	CvdIdAllocatorTest	,
		ClaimAll
	)

TEST_F() [23/41]

cuttlefish::TEST_F	(	CvdIdAllocatorTest	,
		Consecutive
	)

TEST_F() [24/41]

cuttlefish::TEST_F	(	CvdIdAllocatorTest	,
		Reclaim
	)

TEST_F() [25/41]

cuttlefish::TEST_F	(	CvdIdAllocatorTest	,
		StrideBeyond
	)

TEST_F() [26/41]

cuttlefish::TEST_F	(	CvdIdAllocatorTest	,
		Take
	)

TEST_F() [27/41]

cuttlefish::TEST_F	(	CvdIdAllocatorTest	,
		TakeAll
	)

TEST_F() [28/41]

cuttlefish::TEST_F	(	CvdIdAllocatorTest	,
		TakeRange
	)

TEST_F() [29/41]

cuttlefish::TEST_F	(	FetchCvdTests	,
		CasDownloaderInvokedIfDownloaderPathSetInCasConfig
	)

TEST_F() [30/41]

cuttlefish::TEST_F	(	FetchCvdTests	,
		CasDownloaderInvokedIfDownloaderPathSetOnCommandLine
	)

TEST_F() [31/41]

cuttlefish::TEST_F	(	FetchCvdTests	,
		CasDownloaderNotCalledIfNoFlags
	)

TEST_F() [32/41]

cuttlefish::TEST_F	(	FilesTests	,
		HardLinkRecursively
	)

TEST_F() [33/41]

cuttlefish::TEST_F	(	FilesTests	,
		HardLinkRecursivelyFailsIfSourceIsNotADirectory
	)

TEST_F() [34/41]

cuttlefish::TEST_F	(	FilesTests	,
		MoveDirectoryContents
	)

TEST_F() [35/41]

cuttlefish::TEST_F	(	FilesTests	,
		MoveDirectoryContentsFailsIfSourceIsNotADirectory
	)

TEST_F() [36/41]

cuttlefish::TEST_F	(	FlagConsumesArbitraryTest	,
		NoValues
	)

TEST_F() [37/41]

cuttlefish::TEST_F	(	FlagConsumesArbitraryTest	,
		NoValuesOtherFlag
	)

TEST_F() [38/41]

cuttlefish::TEST_F	(	FlagConsumesArbitraryTest	,
		OneValue
	)

TEST_F() [39/41]

cuttlefish::TEST_F	(	FlagConsumesArbitraryTest	,
		OneValueOtherFlag
	)

TEST_F() [40/41]

cuttlefish::TEST_F	(	FlagConsumesArbitraryTest	,
		TwoValues
	)

TEST_F() [41/41]

cuttlefish::TEST_F	(	FlagConsumesArbitraryTest	,
		TwoValuesOtherFlag
	)

TEST_P() [1/4]

cuttlefish::TEST_P	(	EmulateAbsolutePathBase	,
		NoHomeNoPwd
	)

TEST_P() [2/4]

cuttlefish::TEST_P	(	EmulateAbsolutePathWithHome	,
		YesHomeNoPwd
	)

TEST_P() [3/4]

cuttlefish::TEST_P	(	EmulateAbsolutePathWithPwd	,
		NoHomeYesPwd
	)

TEST_P() [4/4]

cuttlefish::TEST_P	(	OneEachTest	,
		GetAnyAvailableOne
	)

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

(

)

ToHexString()

std::string cuttlefish::ToHexString

(

const std::vector< uint8_t > &

binary

)

TokenizeByNullChar()

static std::vector< std::string > cuttlefish::TokenizeByNullChar ( const std::string &  input )

static

Tokenizes the given string, using '\0' as a delimiter

android::base::Tokenize works mostly except the delimiter can't be '\0'. The /proc/<pid>/environ file has the list of environment variables, delimited by '\0'. Needs a dedicated tokenizer.

TombstoneReceiver()

Result< MonitorCommand > cuttlefish::TombstoneReceiver

(

const CuttlefishConfig::InstanceSpecific &

instance

)

TombstoneReceiverBinary()

std::string cuttlefish::TombstoneReceiverBinary

(

)

TombstoneReceiverMain()

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

ToSeverity()

Result< android::base::LogSeverity > cuttlefish::ToSeverity

(

const std::string &

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

(

std::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.

TypeIsSuccess() [1/4]

bool cuttlefish::TypeIsSuccess ( bool  value )

inline

TypeIsSuccess() [2/4]

template<typename T >

bool cuttlefish::TypeIsSuccess

(

Result< T > &&

value

)

TypeIsSuccess() [3/4]

template<typename T >

bool cuttlefish::TypeIsSuccess

(

Result< T > &

value

)

TypeIsSuccess() [4/4]

template<typename T >

bool cuttlefish::TypeIsSuccess

(

std::optional< T > &

value

)

TypeName()

template<typename T >

constexpr std::string_view cuttlefish::TypeName ( )

inlineconstexpr

UnexpectedArgumentGuard()

Flag cuttlefish::UnexpectedArgumentGuard

(

)

UnixMessageSocketPair()

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

(

)

UnpackBootImage()

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

UnpackBootimgBinary()

std::string cuttlefish::UnpackBootimgBinary

(

)

UnpackRamdisk()

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

UnpackVendorBootImageIfNotUnpacked()

bool 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

(

)

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

ValidateCfConfigs()

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

(

const Json::Value &

root

)

ValidateHostConfiguration()

Result< void > cuttlefish::ValidateHostConfiguration

(

)

ValidateHostKernel()

Result< void > cuttlefish::ValidateHostKernel

(

)

ValidateMetricsConfirmation()

std::string cuttlefish::ValidateMetricsConfirmation

(

std::string

use_metrics

)

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

)

VerbosityFlag()

Flag cuttlefish::VerbosityFlag

(

android::base::LogSeverity &

value

)

VerbosityToString()

Result< std::string > cuttlefish::VerbosityToString

(

const android::base::LogSeverity

verbosity

)

VhalProxyServer()

std::optional< MonitorCommand > cuttlefish::VhalProxyServer	(	const CuttlefishConfig &	config,
		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 >, InputConnectionsProvider, LogTeeCreator > cuttlefish::VhostInputDevicesComponent

(

)

VhostUserInputBinary()

std::string cuttlefish::VhostUserInputBinary

(

)

VmManager()

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

static

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 std::function< bool(const std::string &)> &	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
	)

WriteFailureRecordImpl()

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

static

WriteFsConfig()

Result< bool > cuttlefish::WriteFsConfig	(	const char *	output_path,
		const std::string &	fs_root,
		const std::string &	mount_point
	)

WriteGflagsCompatXml()

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

WriteKeyEqualsValue()

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

WriteProtectedJsonToFile()

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

XmlEscape() [1/2]

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

static

XmlEscape() [2/2]

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

static

ZipOpenRead()

Result< ReadableZip > cuttlefish::ZipOpenRead

(

const std::string &

fs_path

)

ZipOpenReadWrite()

Result< WritableZip > cuttlefish::ZipOpenReadWrite

(

const std::string &

fs_path

)

ZipSourceFromUrl()

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

Variable Documentation

_MISC_INFO_FILE_NAME

const std::string cuttlefish::_MISC_INFO_FILE_NAME = "misc_info.txt"

_PRODUCT_IMAGE_NAME_PATTERN

const std::string cuttlefish::_PRODUCT_IMAGE_NAME_PATTERN = "product.img"

_SYSTEM_EXT_IMAGE_NAME_PATTERN

const std::string cuttlefish::_SYSTEM_EXT_IMAGE_NAME_PATTERN = "system_ext.img"

_SYSTEM_IMAGE_NAME_PATTERN

const std::string cuttlefish::_SYSTEM_IMAGE_NAME_PATTERN = "system.img"

_TARGET_FILES_IMAGES_DIR_NAME

const std::string cuttlefish::_TARGET_FILES_IMAGES_DIR_NAME = "IMAGES"

_TARGET_FILES_META_DIR_NAME

const std::string cuttlefish::_TARGET_FILES_META_DIR_NAME = "META"

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"},
}

IfaceTyToStrMap

const std::map< IfaceType, std::string > cuttlefish::IfaceTyToStrMap

Initial value:

= {
    {IfaceType::Invalid, "invalid"}, {IfaceType::mtap, "mtap"},
    {IfaceType::wtap, "wtap"},       {IfaceType::wifiap, "wifiap"},
    {IfaceType::etap, "etap"},       {IfaceType::wbr, "wbr"},
    {IfaceType::ebr, "ebr"}}

kAdbdStartedMessage

constexpr char cuttlefish::kAdbdStartedMessage[]

inlineconstexpr

Initial value:

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

kAdbIPAndPort

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

staticconstexpr

kAndroidBuildApiScope

constexpr char cuttlefish::kAndroidBuildApiScope[]

constexpr

Initial value:

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

kAndroidBuildServiceUrl

constexpr char cuttlefish::kAndroidBuildServiceUrl[]

inlineconstexpr

Initial value:

=
    "https://www.googleapis.com/android/internal/build/v3"

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

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

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

kBootDestPathIA32

constexpr char cuttlefish::kBootDestPathIA32[] = "/EFI/BOOT/BOOTIA32.EFI"

staticconstexpr

kBootDestPathRiscV64

constexpr char cuttlefish::kBootDestPathRiscV64[] = "/EFI/BOOT/BOOTRISCV64.EFI"

staticconstexpr

kBootFailedMessage

constexpr char cuttlefish::kBootFailedMessage[] = "VIRTUAL_DEVICE_BOOT_FAILED"

inlineconstexpr

kBootImage

constexpr char cuttlefish::kBootImage[] = "boot_image"

staticconstexpr

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"

kBootSrcPathIA32

constexpr char cuttlefish::kBootSrcPathIA32[]

staticconstexpr

Initial value:

=
    "/usr/lib/grub/i386-efi/monolithic/grubia32.efi"

kBootStartedMessage

constexpr char cuttlefish::kBootStartedMessage[] = "VIRTUAL_DEVICE_BOOT_STARTED"

inlineconstexpr

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

kCfMetricsQueueName

constexpr char cuttlefish::kCfMetricsQueueName[] = "cf_metrics_msg_queue"

constexpr

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

kConfigServerPort

constexpr char cuttlefish::kConfigServerPort[] = "config_server_port"

staticconstexpr

kConsole

constexpr char cuttlefish::kConsole[] = "console"

staticconstexpr

kCpus

constexpr char cuttlefish::kCpus[] = "cpus"

staticconstexpr

kCrosvmBinary [1/2]

constexpr char cuttlefish::kCrosvmBinary[] = "crosvm_binary"

staticconstexpr

kCrosvmBinary [2/2]

constexpr char cuttlefish::kCrosvmBinary[] = "crosvm_binary"

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

kCurHeaderVersion

constexpr uint16_t cuttlefish::kCurHeaderVersion = 1

constexpr

Current supported Header version number.

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

kCvdallocInterfacePrefix

constexpr std::string_view cuttlefish::kCvdallocInterfacePrefix = "cvd-pi"

constexpr

kCvdDefaultVerbosity

constexpr android::base::LogSeverity cuttlefish::kCvdDefaultVerbosity = android::base::INFO

constexpr

kCvdMarkEnv

constexpr char cuttlefish::kCvdMarkEnv[] = "_STARTED_BY_CVD_SERVER_"

staticconstexpr

kCvdNamePrefix

constexpr char cuttlefish::kCvdNamePrefix[] = "cvd-"

inlineconstexpr

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 std::size_t cuttlefish::kDefaultCacheSizeGb = 25

inlineconstexpr

kDefaultCasConcurrency

constexpr int cuttlefish::kDefaultCasConcurrency = 500

inlineconstexpr

kDefaultCredentialFilepath

constexpr char cuttlefish::kDefaultCredentialFilepath[] = ""

inlineconstexpr

kDefaultCredentialSource

constexpr char cuttlefish::kDefaultCredentialSource[] = ""

inlineconstexpr

kDefaultDownloadImgZip

constexpr bool cuttlefish::kDefaultDownloadImgZip = true

inlineconstexpr

kDefaultDownloadTargetFilesZip

constexpr bool cuttlefish::kDefaultDownloadTargetFilesZip = 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

kDefaultLocation

constexpr char cuttlefish::kDefaultLocation

constexpr

Initial value:

=
    "/var/run/cuttlefish/cuttlefish_allocd.sock"

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

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

kEbtablesLegacyName

constexpr char cuttlefish::kEbtablesLegacyName[] = "ebtables-legacy"

constexpr

kEbtablesName

constexpr char cuttlefish::kEbtablesName[] = "ebtables"

constexpr

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

kEnableHostBluetooth

constexpr char cuttlefish::kEnableHostBluetooth[] = "enable_host_bluetooth"

staticconstexpr

kEnableHostBluetoothConnector

constexpr char cuttlefish::kEnableHostBluetoothConnector[]

staticconstexpr

Initial value:

=
    "enable_host_bluetooth_connector"

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

kEnableMetrics

constexpr char cuttlefish::kEnableMetrics[] = "enable_metrics"

staticconstexpr

kEnableMinimalMode

constexpr char cuttlefish::kEnableMinimalMode[] = "enable_minimal_mode"

staticconstexpr

kEnableMouse

constexpr char cuttlefish::kEnableMouse[] = "enable_mouse"

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

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"

constexpr

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"

kFilenameEncryptionMode

constexpr char cuttlefish::kFilenameEncryptionMode[] = "filename_encryption_mode"

staticconstexpr

kFilesystemFormat

constexpr char cuttlefish::kFilesystemFormat[] = "ext4"

staticconstexpr

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

kFlagServiceAccountJson

constexpr char cuttlefish::kFlagServiceAccountJson[] = "service-account-json"

inlineconstexpr

kFlagUseAdc

constexpr char cuttlefish::kFlagUseAdc[] = "use-adc"

inlineconstexpr

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 char cuttlefish::kGpuModeAuto[] = "auto"

inlineconstexpr

kGpuModeCustom

constexpr char cuttlefish::kGpuModeCustom[] = "custom"

inlineconstexpr

kGpuModeDrmVirgl

constexpr char cuttlefish::kGpuModeDrmVirgl[] = "drm_virgl"

inlineconstexpr

kGpuModeGfxstream

constexpr char cuttlefish::kGpuModeGfxstream[] = "gfxstream"

inlineconstexpr

kGpuModeGfxstreamGuestAngle

constexpr char cuttlefish::kGpuModeGfxstreamGuestAngle[] = "gfxstream_guest_angle"

inlineconstexpr

kGpuModeGfxstreamGuestAngleHostLavapipe

constexpr char cuttlefish::kGpuModeGfxstreamGuestAngleHostLavapipe[]

inlineconstexpr

Initial value:

=
    "gfxstream_guest_angle_host_lavapipe"

kGpuModeGfxstreamGuestAngleHostSwiftShader

constexpr char cuttlefish::kGpuModeGfxstreamGuestAngleHostSwiftShader[]

inlineconstexpr

Initial value:

=
    "gfxstream_guest_angle_host_swiftshader"

kGpuModeGuestSwiftshader

constexpr char cuttlefish::kGpuModeGuestSwiftshader[] = "guest_swiftshader"

inlineconstexpr

kGpuModeNone

constexpr char 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

kGreenColor

constexpr char cuttlefish::kGreenColor[] = "\033[1;32m"

staticconstexpr

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

kGrubModulesPath

constexpr char cuttlefish::kGrubModulesPath[] = "/usr/lib/grub/"

staticconstexpr

kGrubModulesX86

constexpr std::array cuttlefish::kGrubModulesX86

staticconstexpr

Initial value:

{
    "normal", "configfile", "linux", "linuxefi",   "multiboot", "ls",
    "cat",    "help",       "fat",   "part_msdos", "part_gpt"}

kGrubModulesX86Name

constexpr char cuttlefish::kGrubModulesX86Name[] = "i386-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"

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

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

kInternalServerFd

constexpr char cuttlefish::kInternalServerFd[] = "INTERNAL_server_fd"

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

kLaunchedByAcloud

constexpr char cuttlefish::kLaunchedByAcloud[] = "LAUNCHED_BY_ACLOUD"

constexpr

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

kMaxAvbMetadataSize

constexpr uint64_t cuttlefish::kMaxAvbMetadataSize = 69632ul

inlineconstexpr

kMaxCommandLength

constexpr int32_t cuttlefish::kMaxCommandLength = 4096

constexpr

kMaxIfaceNameId

constexpr uint32_t cuttlefish::kMaxIfaceNameId = 63

constexpr

kMaxLogicalChannels

constexpr int cuttlefish::kMaxLogicalChannels = 3

constexpr

kMaxNumberSizeBytes

constexpr int cuttlefish::kMaxNumberSizeBytes = 11

constexpr

kMcu

constexpr char cuttlefish::kMcu[] = "mcu"

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

kMetricsBinary

constexpr char cuttlefish::kMetricsBinary[] = "metrics_binary"

staticconstexpr

kMinHeaderVersion

constexpr uint16_t cuttlefish::kMinHeaderVersion = 1

constexpr

Oldest compatible header version number.

kMixSuperImageHelpMessage

constexpr char cuttlefish::kMixSuperImageHelpMessage[]

staticconstexpr

Initial value:

=
    R"(Cuttlefish Virtual Device (CVD) CLI.
 
usage: cvd acloud mix-super-image <args>
 
Args:
  --super_image               Super image path.
)"

kMobileBridgeName

constexpr char cuttlefish::kMobileBridgeName[] = "mobile_bridge_name"

staticconstexpr

kMobileIp

constexpr char cuttlefish::kMobileIp[] = "192.168.97"

constexpr

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

kMultibootModuleDestPathAA64

constexpr char cuttlefish::kMultibootModuleDestPathAA64[]

staticconstexpr

Initial value:

=
    "/EFI/modules/multiboot.mod"

kMultibootModuleDestPathIA32

constexpr char cuttlefish::kMultibootModuleDestPathIA32[]

staticconstexpr

Initial value:

=
    "/EFI/modules/multiboot.mod"

kMultibootModuleSrcPathAA64

constexpr char cuttlefish::kMultibootModuleSrcPathAA64[]

staticconstexpr

Initial value:

=
    "/usr/lib/grub/arm64-efi/multiboot.mod"

kMultibootModuleSrcPathIA32

constexpr char cuttlefish::kMultibootModuleSrcPathIA32[]

staticconstexpr

Initial value:

=
    "/usr/lib/grub/i386-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>"

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

kNetsimRadios

constexpr char cuttlefish::kNetsimRadios[] = "netsim_radios"

staticconstexpr

kNetworkSelectionMode

constexpr char cuttlefish::kNetworkSelectionMode[] = "network_selection_mode"

staticconstexpr

kNewBootImage

constexpr char cuttlefish::kNewBootImage[] = "new_boot_image"

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>"

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

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

kRecvFlags [1/2]

constexpr int cuttlefish::kRecvFlags = 0

staticconstexpr

kRecvFlags [2/2]

constexpr int cuttlefish::kRecvFlags = 0

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"}

kResetColor

constexpr char cuttlefish::kResetColor[] = "\033[0m"

staticconstexpr

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

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

kSendFlags [1/2]

constexpr int cuttlefish::kSendFlags = 0

staticconstexpr

kSendFlags [2/2]

constexpr int cuttlefish::kSendFlags = 0

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

constexpr

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

kStartVhalProxyServer

constexpr char cuttlefish::kStartVhalProxyServer[] = "start_vhal_proxy_server"

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

kTerminalBoldRed

constexpr char cuttlefish::kTerminalBoldRed[] = "\033[0;1;31m"

staticconstexpr

kTerminalCyan

constexpr char cuttlefish::kTerminalCyan[] = "\033[0;36m"

staticconstexpr

kTerminalRed

constexpr char cuttlefish::kTerminalRed[] = "\033[0;31m"

staticconstexpr

kTerminalReset

constexpr char cuttlefish::kTerminalReset[] = "\033[0m"

staticconstexpr

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

kTranslatorHelpMessage

constexpr char cuttlefish::kTranslatorHelpMessage[]

staticconstexpr

Initial value:

=
    R"(Cuttlefish Virtual Device (CVD) CLI.
 
usage: cvd acloud translator <args>
 
Args:
  --opt-out              Opt-out CVD Acloud and choose to run original Python Acloud.
  --opt-in               Opt-in and run CVD Acloud as default.
Both -opt-out and --opt-in are mutually exclusive.
)"

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"

kUseAllocd

constexpr char cuttlefish::kUseAllocd[] = "use_allocd"

staticconstexpr

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"

constexpr

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

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_MSG_SIZE

const uint32_t cuttlefish::MAX_MSG_SIZE = 200

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

uint 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"

ReqStatusToStrMap

const std::map< RequestStatus, std::string > cuttlefish::ReqStatusToStrMap

Initial value:

= {
    {RequestStatus::Invalid, "invalid"},
    {RequestStatus::Pending, "pending"},
    {RequestStatus::Failure, "failure"},
    {RequestStatus::Success, "success"}}

RequestTyToStrMap

const std::map< RequestType, const char * > cuttlefish::RequestTyToStrMap

Initial value:

= {
    {RequestType::ID, "alloc_id"},
    {RequestType::CreateInterface, "create_interface"},
    {RequestType::DestroyInterface, "destroy_interface"},
    {RequestType::StopSession, "stop_session"},
    {RequestType::Shutdown, "shutdown"},
    {RequestType::Invalid, "invalid"}}

StrToIfaceTyMap

const std::map< std::string, IfaceType > cuttlefish::StrToIfaceTyMap

Initial value:

= {
    {"invalid", IfaceType::Invalid}, {"mtap", IfaceType::mtap},
    {"wtap", IfaceType::wtap},       {"wifiap", IfaceType::wifiap},
    {"etap", IfaceType::etap},       {"wbr", IfaceType::wbr},
    {"ebr", IfaceType::ebr}}

StrToReqStatusMap

const std::map< std::string, RequestStatus > cuttlefish::StrToReqStatusMap

Initial value:

= {
    {"invalid", RequestStatus::Invalid},
    {"pending", RequestStatus::Pending},
    {"failure", RequestStatus::Failure},
    {"success", RequestStatus::Success}}

StrToRequestTyMap

const std::map< std::string, RequestType > cuttlefish::StrToRequestTyMap

Initial value:

= {
    {"alloc_id", RequestType::ID},
    {"create_interface", RequestType::CreateInterface},
    {"destroy_interface", RequestType::DestroyInterface},
    {"stop_session", RequestType::StopSession},
    {"shutdown", RequestType::Shutdown},
    {"invalid", RequestType::Invalid}}

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

verbosity_mutex

std::mutex cuttlefish::verbosity_mutex

static

VIOS_VERSION

const uint32_t cuttlefish::VIOS_VERSION = 2

VIRTIO_SND_CHMAP_MAX_SIZE

constexpr uint8_t cuttlefish::VIRTIO_SND_CHMAP_MAX_SIZE = 18

constexpr