Merge "gralloc4: security review" (461506b6) · Commits · e / os / android_frameworks_native-old

libs/gralloc/types/Gralloc4.cpp

+154 −48

Original line number	Diff line number	Diff line
		@@ -65,6 +65,7 @@ public:
		return BAD_VALUE;
		}
		mVec->resize(mNeededResize);
		mResized = true;
		return NO_ERROR;
		}

		@@ -72,11 +73,17 @@ public:
		if (!mVec) {
		return BAD_VALUE;
		}
		if (mVec->size() == 0) {
		if (!mResized) {
		if (hasAdditionOverflow(mNeededResize, size)) {
		clear();
		return BAD_VALUE;
		}
		/**
		* Update mNeededResize and return NO_ERROR here because if (!mResized), the
		* caller hasn't called resize(). No data will be written into the mVec until
		* the caller resizes. We can't resize here for the caller because hidl_vec::resize()
		* allocates a new backing array every time.
		*/
		mNeededResize += size;
		return NO_ERROR;
		}
		@@ -97,12 +104,14 @@ public:
		mVec->resize(0);
		}
		mNeededResize = 0;
		mResized = false;
		mOffset = 0;
		}

		private:
		hidl_vec<uint8_t>* mVec;
		size_t mNeededResize = 0;
		size_t mResized = false;
		size_t mOffset = 0;
		};

		@@ -142,7 +151,7 @@ public:
		if (!mVec) {
		return false;
		}
		return mVec->size() - mOffset;
		return mVec->size() > mOffset;
		}

		private:
		@@ -170,6 +179,9 @@ using DecodeHelper = status_t()(InputHidlVec, T*);
		template<class T>
		using ErrorHandler = void()(T);

		status_t encodeMetadataType(const MetadataType& input, OutputHidlVec* output);
		status_t validateMetadataType(InputHidlVec* input, const MetadataType& expectedMetadataType);

		/**
		* encode is the main encoding function. It takes in T and uses the encodeHelper function to turn T
		* into the hidl_vec byte stream.
		@@ -179,9 +191,16 @@ using ErrorHandler = void()(T);
		* encodes T into the hidl_vec byte stream.
		*/
		template <class T>
		status_t encode(const T& input, hidl_vec<uint8_t>* output, EncodeHelper<T> encodeHelper) {
		status_t encode(const MetadataType& metadataType, const T& input, hidl_vec<uint8_t>* output,
		EncodeHelper<T> encodeHelper) {
		OutputHidlVec outputHidlVec{output};
		status_t err = encodeHelper(input, &outputHidlVec);

		status_t err = encodeMetadataType(metadataType, &outputHidlVec);
		if (err) {
		return err;
		}

		err = encodeHelper(input, &outputHidlVec);
		if (err) {
		return err;
		}
		@@ -191,6 +210,11 @@ status_t encode(const T& input, hidl_vec<uint8_t>* output, EncodeHelper<T> encod
		return err;
		}

		err = encodeMetadataType(metadataType, &outputHidlVec);
		if (err) {
		return err;
		}

		return encodeHelper(input, &outputHidlVec);
		}

		@@ -200,10 +224,16 @@ status_t encode(const T& input, hidl_vec<uint8_t>* output, EncodeHelper<T> encod
		* T.
		*/
		template <class T>
		status_t decode(const hidl_vec<uint8_t>& input, T* output, DecodeHelper<T> decodeHelper,
		ErrorHandler<T> errorHandler = nullptr) {
		status_t decode(const MetadataType& metadataType, const hidl_vec<uint8_t>& input, T* output,
		DecodeHelper<T> decodeHelper, ErrorHandler<T> errorHandler = nullptr) {
		InputHidlVec inputHidlVec{&input};
		status_t err = decodeHelper(&inputHidlVec, output);

		status_t err = validateMetadataType(&inputHidlVec, metadataType);
		if (err) {
		return err;
		}

		err = decodeHelper(&inputHidlVec, output);
		if (err) {
		return err;
		}
		@@ -256,7 +286,7 @@ status_t encodeString(const std::string& input, OutputHidlVec* output) {
		return err;
		}

		return output->encode(reinterpret_cast<const uint8_t*>(input.c_str()), input.size());
		return output->encode(reinterpret_cast<const uint8_t*>(input.data()), input.size());
		}

		status_t decodeString(InputHidlVec* input, std::string* output) {
		@@ -266,9 +296,12 @@ status_t decodeString(InputHidlVec* input, std::string* output) {

		int64_t size = 0;
		status_t err = decodeInteger<int64_t>(input, &size);
		if (err \|\| size < 0) {
		if (err) {
		return err;
		}
		if (size < 0) {
		return BAD_VALUE;
		}

		return input->decode(output, size);
		}
		@@ -309,6 +342,55 @@ void clearExtendableType(ExtendableType* output) {
		output->value = 0;
		}

		status_t encodeMetadataType(const MetadataType& input, OutputHidlVec* output) {
		status_t err = encodeString(input.name, output);
		if (err) {
		return err;
		}

		err = encodeInteger<int64_t>(input.value, output);
		if (err) {
		return err;
		}

		return NO_ERROR;
		}

		status_t decodeMetadataType(InputHidlVec* input, MetadataType* output) {
		std::string name;
		status_t err = decodeString(input, &name);
		if (err) {
		return err;
		}
		output->name = name;

		err = decodeInteger<int64_t>(input, &output->value);
		if (err) {
		return err;
		}

		return NO_ERROR;
		}

		status_t validateMetadataType(InputHidlVec* input, const MetadataType& expectedMetadataType) {
		MetadataType receivedMetadataType;

		status_t err = decodeMetadataType(input, &receivedMetadataType);
		if (err) {
		return err;
		}

		if (expectedMetadataType.name != receivedMetadataType.name) {
		return BAD_VALUE;
		}

		if (receivedMetadataType.value != expectedMetadataType.value) {
		return BAD_VALUE;
		}

		return NO_ERROR;
		}

		status_t encodeRect(const Rect& input, OutputHidlVec* output) {
		status_t err = encodeInteger<int32_t>(static_cast<int32_t>(input.left), output);
		if (err) {
		@@ -400,13 +482,17 @@ status_t decodePlaneLayoutComponents(InputHidlVec* input, std::vector<PlaneLayou

		int64_t size = 0;
		status_t err = decodeInteger<int64_t>(input, &size);
		if (err \|\| size < 0) {
		if (err) {
		return err;
		}
		if (size < 0 \|\| size > 10000) {
		return BAD_VALUE;
		}

		for (int i = 0; i < size; i++) {
		output->emplace_back();
		err = decodePlaneLayoutComponent(input, &output->back());
		output->resize(size);

		for (auto& planeLayoutComponent : *output) {
		err = decodePlaneLayoutComponent(input, &planeLayoutComponent);
		if (err) {
		return err;
		}
		@@ -525,9 +611,12 @@ status_t encodePlaneLayoutsHelper(const std::vector<PlaneLayout>& planeLayouts,
		status_t decodePlaneLayoutsHelper(InputHidlVec* inputHidlVec, std::vector<PlaneLayout>* outPlaneLayouts) {
		int64_t size = 0;
		status_t err = decodeInteger<int64_t>(inputHidlVec, &size);
		if (err \|\| size < 0) {
		if (err) {
		return err;
		}
		if (size < 0) {
		return BAD_VALUE;
		}

		for (size_t i = 0; i < size; i++) {
		outPlaneLayouts->emplace_back();
		@@ -555,141 +644,158 @@ PlaneLayoutComponentType getStandardPlaneLayoutComponentTypeValue(
		}

		status_t encodeBufferId(uint64_t bufferId, hidl_vec<uint8_t>* outBufferId) {
		return encode(bufferId, outBufferId, encodeInteger);
		return encode(MetadataType_BufferId, bufferId, outBufferId, encodeInteger);
		}

		status_t decodeBufferId(const hidl_vec<uint8_t>& bufferId, uint64_t* outBufferId) {
		return decode(bufferId, outBufferId, decodeInteger);
		return decode(MetadataType_BufferId, bufferId, outBufferId, decodeInteger);
		}

		status_t encodeName(const std::string& name, hidl_vec<uint8_t>* outName) {
		return encode(name, outName, encodeString);
		return encode(MetadataType_Name, name, outName, encodeString);
		}

		status_t decodeName(const hidl_vec<uint8_t>& name, std::string* outName) {
		return decode(name, outName, decodeString);
		return decode(MetadataType_Name, name, outName, decodeString);
		}

		status_t encodeWidth(uint64_t width, hidl_vec<uint8_t>* outWidth) {
		return encode(width, outWidth, encodeInteger);
		return encode(MetadataType_Width, width, outWidth, encodeInteger);
		}

		status_t decodeWidth(const hidl_vec<uint8_t>& width, uint64_t* outWidth) {
		return decode(width, outWidth, decodeInteger);
		return decode(MetadataType_Width, width, outWidth, decodeInteger);
		}

		status_t encodeHeight(uint64_t height, hidl_vec<uint8_t>* outHeight) {
		return encode(height, outHeight, encodeInteger);
		return encode(MetadataType_Height, height, outHeight, encodeInteger);
		}

		status_t decodeHeight(const hidl_vec<uint8_t>& height, uint64_t* outHeight) {
		return decode(height, outHeight, decodeInteger);
		return decode(MetadataType_Height, height, outHeight, decodeInteger);
		}

		status_t encodeLayerCount(uint64_t layerCount, hidl_vec<uint8_t>* outLayerCount) {
		return encode(layerCount, outLayerCount, encodeInteger);
		return encode(MetadataType_LayerCount, layerCount, outLayerCount, encodeInteger);
		}

		status_t decodeLayerCount(const hidl_vec<uint8_t>& layerCount, uint64_t* outLayerCount) {
		return decode(layerCount, outLayerCount, decodeInteger);
		return decode(MetadataType_LayerCount, layerCount, outLayerCount, decodeInteger);
		}

		status_t encodePixelFormatRequested(const hardware::graphics::common::V1_2::PixelFormat& pixelFormatRequested,
		hidl_vec<uint8_t>* outPixelFormatRequested) {
		return encode(static_cast<int32_t>(pixelFormatRequested), outPixelFormatRequested, encodeInteger);
		return encode(MetadataType_PixelFormatRequested, static_cast<int32_t>(pixelFormatRequested),
		outPixelFormatRequested, encodeInteger);
		}

		status_t decodePixelFormatRequested(const hidl_vec<uint8_t>& pixelFormatRequested,
		hardware::graphics::common::V1_2::PixelFormat* outPixelFormatRequested) {
		return decode(pixelFormatRequested, reinterpret_cast<int32_t*>(outPixelFormatRequested), decodeInteger);
		return decode(MetadataType_PixelFormatRequested, pixelFormatRequested,
		reinterpret_cast<int32_t*>(outPixelFormatRequested), decodeInteger);
		}

		status_t encodePixelFormatFourCC(uint32_t pixelFormatFourCC, hidl_vec<uint8_t>* outPixelFormatFourCC) {
		return encode(pixelFormatFourCC, outPixelFormatFourCC, encodeInteger);
		return encode(MetadataType_PixelFormatFourCC, pixelFormatFourCC, outPixelFormatFourCC,
		encodeInteger);
		}

		status_t decodePixelFormatFourCC(const hidl_vec<uint8_t>& pixelFormatFourCC, uint32_t* outPixelFormatFourCC) {
		return decode(pixelFormatFourCC, outPixelFormatFourCC, decodeInteger);
		return decode(MetadataType_PixelFormatFourCC, pixelFormatFourCC, outPixelFormatFourCC,
		decodeInteger);
		}

		status_t encodePixelFormatModifier(uint64_t pixelFormatModifier, hidl_vec<uint8_t>* outPixelFormatModifier) {
		return encode(pixelFormatModifier, outPixelFormatModifier, encodeInteger);
		return encode(MetadataType_PixelFormatModifier, pixelFormatModifier, outPixelFormatModifier,
		encodeInteger);
		}

		status_t decodePixelFormatModifier(const hidl_vec<uint8_t>& pixelFormatModifier, uint64_t* outPixelFormatModifier) {
		return decode(pixelFormatModifier, outPixelFormatModifier, decodeInteger);
		return decode(MetadataType_PixelFormatModifier, pixelFormatModifier, outPixelFormatModifier,
		decodeInteger);
		}

		status_t encodeUsage(uint64_t usage, hidl_vec<uint8_t>* outUsage) {
		return encode(usage, outUsage, encodeInteger);
		return encode(MetadataType_Usage, usage, outUsage, encodeInteger);
		}

		status_t decodeUsage(const hidl_vec<uint8_t>& usage, uint64_t* outUsage) {
		return decode(usage, outUsage, decodeInteger);
		return decode(MetadataType_Usage, usage, outUsage, decodeInteger);
		}

		status_t encodeAllocationSize(uint64_t allocationSize, hidl_vec<uint8_t>* outAllocationSize) {
		return encode(allocationSize, outAllocationSize, encodeInteger);
		return encode(MetadataType_AllocationSize, allocationSize, outAllocationSize, encodeInteger);
		}

		status_t decodeAllocationSize(const hidl_vec<uint8_t>& allocationSize, uint64_t* outAllocationSize) {
		return decode(allocationSize, outAllocationSize, decodeInteger);
		return decode(MetadataType_AllocationSize, allocationSize, outAllocationSize, decodeInteger);
		}

		status_t encodeProtectedContent(uint64_t protectedContent, hidl_vec<uint8_t>* outProtectedContent) {
		return encode(protectedContent, outProtectedContent, encodeInteger);
		return encode(MetadataType_ProtectedContent, protectedContent, outProtectedContent,
		encodeInteger);
		}

		status_t decodeProtectedContent(const hidl_vec<uint8_t>& protectedContent, uint64_t* outProtectedContent) {
		return decode(protectedContent, outProtectedContent, decodeInteger);
		return decode(MetadataType_ProtectedContent, protectedContent, outProtectedContent,
		decodeInteger);
		}

		status_t encodeCompression(const ExtendableType& compression, hidl_vec<uint8_t>* outCompression) {
		return encode(compression, outCompression, encodeExtendableType);
		return encode(MetadataType_Compression, compression, outCompression, encodeExtendableType);
		}

		status_t decodeCompression(const hidl_vec<uint8_t>& compression, ExtendableType* outCompression) {
		return decode(compression, outCompression, decodeExtendableType, clearExtendableType);
		return decode(MetadataType_Compression, compression, outCompression, decodeExtendableType,
		clearExtendableType);
		}

		status_t encodeInterlaced(const ExtendableType& interlaced, hidl_vec<uint8_t>* outInterlaced) {
		return encode(interlaced, outInterlaced, encodeExtendableType);
		return encode(MetadataType_Interlaced, interlaced, outInterlaced, encodeExtendableType);
		}

		status_t decodeInterlaced(const hidl_vec<uint8_t>& interlaced, ExtendableType* outInterlaced) {
		return decode(interlaced, outInterlaced, decodeExtendableType, clearExtendableType);
		return decode(MetadataType_Interlaced, interlaced, outInterlaced, decodeExtendableType,
		clearExtendableType);
		}

		status_t encodeChromaSiting(const ExtendableType& chromaSiting, hidl_vec<uint8_t>* outChromaSiting) {
		return encode(chromaSiting, outChromaSiting, encodeExtendableType);
		return encode(MetadataType_ChromaSiting, chromaSiting, outChromaSiting, encodeExtendableType);
		}

		status_t decodeChromaSiting(const hidl_vec<uint8_t>& chromaSiting, ExtendableType* outChromaSiting) {
		return decode(chromaSiting, outChromaSiting, decodeExtendableType, clearExtendableType);
		return decode(MetadataType_ChromaSiting, chromaSiting, outChromaSiting, decodeExtendableType,
		clearExtendableType);
		}

		status_t encodePlaneLayouts(const std::vector<PlaneLayout>& planeLayouts, hidl_vec<uint8_t>* outPlaneLayouts) {
		return encode(planeLayouts, outPlaneLayouts, encodePlaneLayoutsHelper);
		return encode(MetadataType_PlaneLayouts, planeLayouts, outPlaneLayouts,
		encodePlaneLayoutsHelper);
		}

		status_t decodePlaneLayouts(const hidl_vec<uint8_t>& planeLayouts, std::vector<PlaneLayout>* outPlaneLayouts) {
		return decode(planeLayouts, outPlaneLayouts, decodePlaneLayoutsHelper, clearPlaneLayouts);
		return decode(MetadataType_PlaneLayouts, planeLayouts, outPlaneLayouts,
		decodePlaneLayoutsHelper, clearPlaneLayouts);
		}

		status_t encodeDataspace(const Dataspace& dataspace, hidl_vec<uint8_t>* outDataspace) {
		return encode(static_cast<int32_t>(dataspace), outDataspace, encodeInteger);
		return encode(MetadataType_Dataspace, static_cast<int32_t>(dataspace), outDataspace,
		encodeInteger);
		}

		status_t decodeDataspace(const hidl_vec<uint8_t>& dataspace, Dataspace* outDataspace) {
		return decode(dataspace, reinterpret_cast<int32_t*>(outDataspace), decodeInteger);
		return decode(MetadataType_Dataspace, dataspace, reinterpret_cast<int32_t*>(outDataspace),
		decodeInteger);
		}

		status_t encodeBlendMode(const BlendMode& blendMode, hidl_vec<uint8_t>* outBlendMode) {
		return encode(static_cast<int32_t>(blendMode), outBlendMode, encodeInteger);
		return encode(MetadataType_BlendMode, static_cast<int32_t>(blendMode), outBlendMode,
		encodeInteger);
		}

		status_t decodeBlendMode(const hidl_vec<uint8_t>& blendMode, BlendMode* outBlendMode) {
		return decode(blendMode, reinterpret_cast<int32_t*>(outBlendMode), decodeInteger);
		return decode(MetadataType_BlendMode, blendMode, reinterpret_cast<int32_t*>(outBlendMode),
		decodeInteger);
		}

		bool isStandardMetadataType(const MetadataType& metadataType) {