aota

type ApexInfo struct {
	PackageName      *string `protobuf:"bytes,1,opt,name=package_name,json=packageName,proto3,oneof" json:"package_name,omitempty"`
	Version          *int64  `protobuf:"varint,2,opt,name=version,proto3,oneof" json:"version,omitempty"`
	IsCompressed     *bool   `protobuf:"varint,3,opt,name=is_compressed,json=isCompressed,proto3,oneof" json:"is_compressed,omitempty"`
	DecompressedSize *int64  `protobuf:"varint,4,opt,name=decompressed_size,json=decompressedSize,proto3,oneof" json:"decompressed_size,omitempty"`
	// Used in OTA
	SourceVersion *int64 `protobuf:"varint,5,opt,name=source_version,json=sourceVersion,proto3,oneof" json:"source_version,omitempty"`
	// contains filtered or unexported fields
}

type ApexMetadata struct {
	ApexInfo []*ApexInfo `protobuf:"bytes,1,rep,name=apex_info,json=apexInfo,proto3" json:"apex_info,omitempty"`
	// contains filtered or unexported fields
}

type CowMergeOperation struct {
	Type      *CowMergeOperation_Type `protobuf:"varint,1,opt,name=type,proto3,enum=chromeos_update_engine.CowMergeOperation_Type,oneof" json:"type,omitempty"`
	SrcExtent *Extent                 `protobuf:"bytes,2,opt,name=src_extent,json=srcExtent,proto3,oneof" json:"src_extent,omitempty"`
	DstExtent *Extent                 `protobuf:"bytes,3,opt,name=dst_extent,json=dstExtent,proto3,oneof" json:"dst_extent,omitempty"`
	// For COW_XOR, source location might be unaligned, so this field is in range
	// [0, block_size), representing how much should the src_extent shift toward
	// larger block number. If this field is non-zero, then src_extent will
	// include 1 extra block in the end, as the merge op actually references the
	// first |src_offset| bytes of that extra block. For example, if |dst_extent|
	// is [10, 15], |src_offset| is 500, then src_extent might look like [25, 31].
	// Note that |src_extent| contains 1 extra block than the |dst_extent|.
	SrcOffset *uint32 `protobuf:"varint,4,opt,name=src_offset,json=srcOffset,proto3,oneof" json:"src_offset,omitempty"`
	// contains filtered or unexported fields
}

type CowMergeOperation_Type int32

type DeltaArchiveManifest struct {

	// (At time of writing) usually 4096
	BlockSize *uint32 `protobuf:"varint,3,opt,name=block_size,json=blockSize,proto3,oneof" json:"block_size,omitempty"`
	// If signatures are present, the offset into the blobs, generally
	// tacked onto the end of the file, and the length. We use an offset
	// rather than a bool to allow for more flexibility in future file formats.
	// If either is absent, it means signatures aren't supported in this
	// file.
	SignaturesOffset *uint64 `protobuf:"varint,4,opt,name=signatures_offset,json=signaturesOffset,proto3,oneof" json:"signatures_offset,omitempty"`
	SignaturesSize   *uint64 `protobuf:"varint,5,opt,name=signatures_size,json=signaturesSize,proto3,oneof" json:"signatures_size,omitempty"`
	// The minor version, also referred as "delta version", of the payload.
	// Minor version 0 is full payload, everything else is delta payload.
	MinorVersion *uint32 `protobuf:"varint,12,opt,name=minor_version,json=minorVersion,proto3,oneof" json:"minor_version,omitempty"`
	// Only present in major version >= 2. List of partitions that will be
	// updated, in the order they will be updated. This field replaces the
	// |install_operations|, |kernel_install_operations| and the
	// |{old,new}_{kernel,rootfs}_info| fields used in major version = 1. This
	// array can have more than two partitions if needed, and they are identified
	// by the partition name.
	Partitions []*PartitionUpdate `protobuf:"bytes,13,rep,name=partitions,proto3" json:"partitions,omitempty"`
	// The maximum timestamp of the OS allowed to apply this payload.
	// Can be used to prevent downgrading the OS.
	MaxTimestamp *int64 `protobuf:"varint,14,opt,name=max_timestamp,json=maxTimestamp,proto3,oneof" json:"max_timestamp,omitempty"`
	// Metadata related to all dynamic partitions.
	DynamicPartitionMetadata *DynamicPartitionMetadata `` /* 142-byte string literal not displayed */
	// If the payload only updates a subset of partitions on the device.
	PartialUpdate *bool `protobuf:"varint,16,opt,name=partial_update,json=partialUpdate,proto3,oneof" json:"partial_update,omitempty"`
	// Information on compressed APEX to figure out how much space is required for
	// their decompression
	ApexInfo []*ApexInfo `protobuf:"bytes,17,rep,name=apex_info,json=apexInfo,proto3" json:"apex_info,omitempty"`
	// Security patch level of the device, usually in the format of
	// yyyy-mm-dd
	SecurityPatchLevel *string `protobuf:"bytes,18,opt,name=security_patch_level,json=securityPatchLevel,proto3,oneof" json:"security_patch_level,omitempty"`
	// contains filtered or unexported fields
}

type DeviceState struct {

	// device name. i.e. ro.product.device; if the field has multiple values, it
	// means the ota package supports multiple devices. This usually happens when
	// we use the same image to support multiple skus.
	Device []string `protobuf:"bytes,1,rep,name=device,proto3" json:"device,omitempty"`
	// device fingerprint. Up to R build, the value reads from
	// ro.build.fingerprint.
	Build []string `protobuf:"bytes,2,rep,name=build,proto3" json:"build,omitempty"`
	// A value that specify a version of the android build.
	BuildIncremental string `protobuf:"bytes,3,opt,name=build_incremental,json=buildIncremental,proto3" json:"build_incremental,omitempty"`
	// The timestamp when the build is generated.
	Timestamp int64 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// The version of the currently-executing Android system.
	SdkLevel string `protobuf:"bytes,5,opt,name=sdk_level,json=sdkLevel,proto3" json:"sdk_level,omitempty"`
	// A value indicating the security patch level of a build.
	SecurityPatchLevel string `protobuf:"bytes,6,opt,name=security_patch_level,json=securityPatchLevel,proto3" json:"security_patch_level,omitempty"`
	// The detailed state of each partition. For partial updates or devices with
	// mixed build of partitions, some of the above fields may left empty. And the
	// client will rely on the information of specific partitions to target the
	// update.
	PartitionState []*PartitionState `protobuf:"bytes,7,rep,name=partition_state,json=partitionState,proto3" json:"partition_state,omitempty"`
	// contains filtered or unexported fields
}

type DynamicPartitionGroup struct {

	// Name of the group.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Maximum size of the group. The sum of sizes of all partitions in the group
	// must not exceed the maximum size of the group.
	Size *uint64 `protobuf:"varint,2,opt,name=size,proto3,oneof" json:"size,omitempty"`
	// A list of partitions that belong to the group.
	PartitionNames []string `protobuf:"bytes,3,rep,name=partition_names,json=partitionNames,proto3" json:"partition_names,omitempty"`
	// contains filtered or unexported fields
}

type DynamicPartitionMetadata struct {

	// All updatable groups present in |partitions| of this DeltaArchiveManifest.
	//   - If an updatable group is on the device but not in the manifest, it is
	//     not updated. Hence, the group will not be resized, and partitions cannot
	//     be added to or removed from the group.
	//   - If an updatable group is in the manifest but not on the device, the group
	//     is added to the device.
	Groups []*DynamicPartitionGroup `protobuf:"bytes,1,rep,name=groups,proto3" json:"groups,omitempty"`
	// Whether dynamic partitions have snapshots during the update. If this is
	// set to true, the update_engine daemon creates snapshots for all dynamic
	// partitions if possible. If this is unset, the update_engine daemon MUST
	// NOT create snapshots for dynamic partitions.
	SnapshotEnabled *bool `protobuf:"varint,2,opt,name=snapshot_enabled,json=snapshotEnabled,proto3,oneof" json:"snapshot_enabled,omitempty"`
	// If this is set to false, update_engine should not use VABC regardless. If
	// this is set to true, update_engine may choose to use VABC if device
	// supports it, but not guaranteed.
	// VABC stands for Virtual AB Compression
	VabcEnabled *bool `protobuf:"varint,3,opt,name=vabc_enabled,json=vabcEnabled,proto3,oneof" json:"vabc_enabled,omitempty"`
	// The compression algorithm used by VABC. Available ones are "gz", "brotli".
	// See system/core/fs_mgr/libsnapshot/cow_writer.cpp for available options,
	// as this parameter is ultimated forwarded to libsnapshot's CowWriter
	VabcCompressionParam *string `` /* 129-byte string literal not displayed */
	// COW version used by VABC. The represents the major version in the COW
	// header
	CowVersion *uint32 `protobuf:"varint,5,opt,name=cow_version,json=cowVersion,proto3,oneof" json:"cow_version,omitempty"`
	// A collection of knobs to tune Virtual AB Compression
	VabcFeatureSet *VABCFeatureSet `protobuf:"bytes,6,opt,name=vabc_feature_set,json=vabcFeatureSet,proto3,oneof" json:"vabc_feature_set,omitempty"`
	// contains filtered or unexported fields
}

type Extent struct {
	StartBlock *uint64 `protobuf:"varint,1,opt,name=start_block,json=startBlock,proto3,oneof" json:"start_block,omitempty"`
	NumBlocks  *uint64 `protobuf:"varint,2,opt,name=num_blocks,json=numBlocks,proto3,oneof" json:"num_blocks,omitempty"`
	// contains filtered or unexported fields
}

type InstallOpStep struct {
	Op  int
	Iop *InstallOpsPartition
}

type InstallOperation struct {
	Type InstallOperation_Type `protobuf:"varint,1,opt,name=type,proto3,enum=chromeos_update_engine.InstallOperation_Type" json:"type,omitempty"`
	// Only minor version 6 or newer support 64 bits |data_offset| and
	// |data_length|, older client will read them as uint32.
	// The offset into the delta file (after the protobuf)
	// where the data (if any) is stored
	DataOffset *uint64 `protobuf:"varint,2,opt,name=data_offset,json=dataOffset,proto3,oneof" json:"data_offset,omitempty"`
	// The length of the data in the delta file
	DataLength *uint64 `protobuf:"varint,3,opt,name=data_length,json=dataLength,proto3,oneof" json:"data_length,omitempty"`
	// Ordered list of extents that are read from (if any) and written to.
	SrcExtents []*Extent `protobuf:"bytes,4,rep,name=src_extents,json=srcExtents,proto3" json:"src_extents,omitempty"`
	// Byte length of src, equal to the number of blocks in src_extents *
	// block_size. It is used for BSDIFF and SOURCE_BSDIFF, because we need to
	// pass that external program the number of bytes to read from the blocks we
	// pass it.  This is not used in any other operation.
	SrcLength  *uint64   `protobuf:"varint,5,opt,name=src_length,json=srcLength,proto3,oneof" json:"src_length,omitempty"`
	DstExtents []*Extent `protobuf:"bytes,6,rep,name=dst_extents,json=dstExtents,proto3" json:"dst_extents,omitempty"`
	// Byte length of dst, equal to the number of blocks in dst_extents *
	// block_size. Used for BSDIFF and SOURCE_BSDIFF, but not in any other
	// operation.
	DstLength *uint64 `protobuf:"varint,7,opt,name=dst_length,json=dstLength,proto3,oneof" json:"dst_length,omitempty"`
	// Optional SHA 256 hash of the blob associated with this operation.
	// This is used as a primary validation for http-based downloads and
	// as a defense-in-depth validation for https-based downloads. If
	// the operation doesn't refer to any blob, this field will have
	// zero bytes.
	DataSha256Hash []byte `protobuf:"bytes,8,opt,name=data_sha256_hash,json=dataSha256Hash,proto3,oneof" json:"data_sha256_hash,omitempty"`
	// Indicates the SHA 256 hash of the source data referenced in src_extents at
	// the time of applying the operation. If present, the update_engine daemon
	// MUST read and verify the source data before applying the operation.
	SrcSha256Hash []byte `protobuf:"bytes,9,opt,name=src_sha256_hash,json=srcSha256Hash,proto3,oneof" json:"src_sha256_hash,omitempty"`
	// contains filtered or unexported fields
}

type InstallOperation_Type int32

type InstallOps struct {
	Map     []*InstallOpsPartition //Used to map a raw operation step to a partition
	Ops     []*InstallOperation    //Buffered install operation steps
	Steps   []InstallOpStep        //Ordered index mapping of install operations
	Session *InstallOpsSession     //Tracks an ongoing installation

	Payload    *Payload //The raw payload holding these ops
	BlockSize  uint64   //The size to zero-pad install operations to
	BaseOffset uint64   //Offset of install data after header
	// contains filtered or unexported fields
}

type InstallOpsPartition struct {
	sync.Mutex //Locks writes to the extracted file

	Name string
	Ops  int
	Size uint64
	File *os.File
}

type InstallOpsSession struct {
	sync.Mutex //Locks changes to stats to prevent stat confusion

	Threads sync.WaitGroup //Threads remaining
}

type InstallSession struct {
	Payloads []*Payload
	Usage    InstallSessionUsage
	Debug    bool
	// contains filtered or unexported fields
}

type InstallSessionUsage struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type OtaMetadata struct {
	Type OtaMetadata_OtaType `protobuf:"varint,1,opt,name=type,proto3,enum=chromeos_update_engine.OtaMetadata_OtaType" json:"type,omitempty"`
	// True if we need to wipe after the update.
	Wipe bool `protobuf:"varint,2,opt,name=wipe,proto3" json:"wipe,omitempty"`
	// True if the timestamp of the post build is older than the pre build.
	Downgrade bool `protobuf:"varint,3,opt,name=downgrade,proto3" json:"downgrade,omitempty"`
	// A map of name:content of property files, e.g. ota-property-files.
	PropertyFiles map[string]string `` /* 188-byte string literal not displayed */
	// The required device state in order to install the package.
	Precondition *DeviceState `protobuf:"bytes,5,opt,name=precondition,proto3" json:"precondition,omitempty"`
	// The expected device state after the update.
	Postcondition *DeviceState `protobuf:"bytes,6,opt,name=postcondition,proto3" json:"postcondition,omitempty"`
	// True if the ota that updates a device to support dynamic partitions, where
	// the source build doesn't support it.
	RetrofitDynamicPartitions bool `` /* 139-byte string literal not displayed */
	// The required size of the cache partition, only valid for non-A/B update.
	RequiredCache int64 `protobuf:"varint,8,opt,name=required_cache,json=requiredCache,proto3" json:"required_cache,omitempty"`
	// True iff security patch level downgrade is permitted on this OTA.
	SplDowngrade bool `protobuf:"varint,9,opt,name=spl_downgrade,json=splDowngrade,proto3" json:"spl_downgrade,omitempty"`
	// contains filtered or unexported fields
}

type OtaMetadata_OtaType int32

type PartitionInfo struct {
	Size *uint64 `protobuf:"varint,1,opt,name=size,proto3,oneof" json:"size,omitempty"`
	Hash []byte  `protobuf:"bytes,2,opt,name=hash,proto3,oneof" json:"hash,omitempty"`
	// contains filtered or unexported fields
}

type PartitionState struct {
	PartitionName string   `protobuf:"bytes,1,opt,name=partition_name,json=partitionName,proto3" json:"partition_name,omitempty"`
	Device        []string `protobuf:"bytes,2,rep,name=device,proto3" json:"device,omitempty"`
	Build         []string `protobuf:"bytes,3,rep,name=build,proto3" json:"build,omitempty"`
	// The version string of the partition. It's usually timestamp if present.
	// One known exception is the boot image, who uses the kmi version, e.g.
	// 5.4.42-android12-0
	Version string `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
	// contains filtered or unexported fields
}

type PartitionUpdate struct {

	// A platform-specific name to identify the partition set being updated. For
	// example, in Chrome OS this could be "ROOT" or "KERNEL".
	PartitionName string `protobuf:"bytes,1,opt,name=partition_name,json=partitionName,proto3" json:"partition_name,omitempty"`
	// Whether this partition carries a filesystem with post-install program that
	// must be run to finalize the update process. See also |postinstall_path| and
	// |filesystem_type|.
	RunPostinstall *bool `protobuf:"varint,2,opt,name=run_postinstall,json=runPostinstall,proto3,oneof" json:"run_postinstall,omitempty"`
	// The path of the executable program to run during the post-install step,
	// relative to the root of this filesystem. If not set, the default "postinst"
	// will be used. This setting is only used when |run_postinstall| is set and
	// true.
	PostinstallPath *string `protobuf:"bytes,3,opt,name=postinstall_path,json=postinstallPath,proto3,oneof" json:"postinstall_path,omitempty"`
	// The filesystem type as passed to the mount(2) syscall when mounting the new
	// filesystem to run the post-install program. If not set, a fixed list of
	// filesystems will be attempted. This setting is only used if
	// |run_postinstall| is set and true.
	FilesystemType *string `protobuf:"bytes,4,opt,name=filesystem_type,json=filesystemType,proto3,oneof" json:"filesystem_type,omitempty"`
	// If present, a list of signatures of the new_partition_info.hash signed with
	// different keys. If the update_engine daemon requires vendor-signed images
	// and has its public key installed, one of the signatures should be valid
	// for /postinstall to run.
	NewPartitionSignature []*Signatures_Signature `` /* 126-byte string literal not displayed */
	OldPartitionInfo      *PartitionInfo          `protobuf:"bytes,6,opt,name=old_partition_info,json=oldPartitionInfo,proto3,oneof" json:"old_partition_info,omitempty"`
	NewPartitionInfo      *PartitionInfo          `protobuf:"bytes,7,opt,name=new_partition_info,json=newPartitionInfo,proto3,oneof" json:"new_partition_info,omitempty"`
	// The list of operations to be performed to apply this PartitionUpdate. The
	// associated operation blobs (in operations[i].data_offset, data_length)
	// should be stored contiguously and in the same order.
	Operations []*InstallOperation `protobuf:"bytes,8,rep,name=operations,proto3" json:"operations,omitempty"`
	// Whether a failure in the postinstall step for this partition should be
	// ignored.
	PostinstallOptional *bool `protobuf:"varint,9,opt,name=postinstall_optional,json=postinstallOptional,proto3,oneof" json:"postinstall_optional,omitempty"`
	// The extent for data covered by verity hash tree.
	HashTreeDataExtent *Extent `` /* 126-byte string literal not displayed */
	// The extent to store verity hash tree.
	HashTreeExtent *Extent `protobuf:"bytes,11,opt,name=hash_tree_extent,json=hashTreeExtent,proto3,oneof" json:"hash_tree_extent,omitempty"`
	// The hash algorithm used in verity hash tree.
	HashTreeAlgorithm *string `protobuf:"bytes,12,opt,name=hash_tree_algorithm,json=hashTreeAlgorithm,proto3,oneof" json:"hash_tree_algorithm,omitempty"`
	// The salt used for verity hash tree.
	HashTreeSalt []byte `protobuf:"bytes,13,opt,name=hash_tree_salt,json=hashTreeSalt,proto3,oneof" json:"hash_tree_salt,omitempty"`
	// The extent for data covered by FEC.
	FecDataExtent *Extent `protobuf:"bytes,14,opt,name=fec_data_extent,json=fecDataExtent,proto3,oneof" json:"fec_data_extent,omitempty"`
	// The extent to store FEC.
	FecExtent *Extent `protobuf:"bytes,15,opt,name=fec_extent,json=fecExtent,proto3,oneof" json:"fec_extent,omitempty"`
	// The number of FEC roots (default should be 2).
	FecRoots *uint32 `protobuf:"varint,16,opt,name=fec_roots,json=fecRoots,proto3,oneof" json:"fec_roots,omitempty"`
	// Per-partition version used for downgrade detection, added
	// as an effort to support partial updates. For most partitions,
	// this is the build timestamp.
	Version *string `protobuf:"bytes,17,opt,name=version,proto3,oneof" json:"version,omitempty"`
	// A sorted list of CowMergeOperation. When writing cow, we can choose to
	// skip writing the raw bytes for these extents. During snapshot merge, the
	// bytes will read from the source partitions instead.
	MergeOperations []*CowMergeOperation `protobuf:"bytes,18,rep,name=merge_operations,json=mergeOperations,proto3" json:"merge_operations,omitempty"`
	// Estimated size for COW image. This is used by libsnapshot
	// as a hint. If set to 0, libsnapshot should use alternative
	// methods for estimating size.
	EstimateCowSize *uint64 `protobuf:"varint,19,opt,name=estimate_cow_size,json=estimateCowSize,proto3,oneof" json:"estimate_cow_size,omitempty"`
	// contains filtered or unexported fields
}

type Payload struct {
	sync.Mutex //Locks attempts to seek or read the consumer

	Temporary bool
	In        string
	Extract   []string
	Manifest  *DeltaArchiveManifest
	Metadata  *OtaMetadata

	BaseOffset uint64
	BlockSize  uint64
	Partitions []*PartitionUpdate

	Consumer         *PayloadConsumer
	MetadataConsumer io.ReadCloser
	Installer        *InstallOps
	InstallSession   *InstallSession
}

type PayloadConsumer struct {
	Seekable io.ReadSeekCloser
	Readable io.ReadCloser
}

type Signatures struct {
	Signatures []*Signatures_Signature `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"`
	// contains filtered or unexported fields
}

type Signatures_Signature struct {

	// Deprecated: Marked as deprecated in aota.proto.
	Version *uint32 `protobuf:"varint,1,opt,name=version,proto3,oneof" json:"version,omitempty"`
	Data    []byte  `protobuf:"bytes,2,opt,name=data,proto3,oneof" json:"data,omitempty"`
	// The DER encoded signature size of EC keys is nondeterministic for
	// different input of sha256 hash. However, we need the size of the
	// serialized signatures protobuf string to be fixed before signing;
	// because this size is part of the content to be signed. Therefore, we
	// always pad the signature data to the maximum possible signature size of
	// a given key. And the payload verifier will truncate the signature to
	// its correct size based on the value of |unpadded_signature_size|.
	UnpaddedSignatureSize *uint32 `` /* 134-byte string literal not displayed */
	// contains filtered or unexported fields
}

type VABCFeatureSet struct {
	Threaded    *bool `protobuf:"varint,1,opt,name=threaded,proto3,oneof" json:"threaded,omitempty"`
	BatchWrites *bool `protobuf:"varint,2,opt,name=batch_writes,json=batchWrites,proto3,oneof" json:"batch_writes,omitempty"`
	// contains filtered or unexported fields
}