Star9
201
代码
代码
Issues27
Pull Requests16
项目讨论
Wiki
分析
Star9
201
已开启
avmemory 子类加固 memFlag 校验与对齐 + 代码同步 #2744
lzm创建于 22 天前
avmemory 子类加固 memFlag 校验与对齐 + 代码同步 #2744
已开启
lzm创建于 22 天前
从lzm233/multimedia_media_foundationavmemory-subclass-harden-7.0合入到openharmony/multimedia_media_foundationOpenHarmony-7.0-Release
共 7 个文件变更+35-270
Msrc/buffer/avbuffer/av_hardware_memory.cpp+9-1
@@ -176,7 +176,15 @@ Status AVHardwareMemory::Init(MessageParcel &parcel)
176 int32_t fd = parcel.ReadFileDescriptor();176 int32_t fd = parcel.ReadFileDescriptor();
177 FALSE_RETURN_V_MSG_E(fd > 0, Status::ERROR_INVALID_DATA, "File descriptor is invalid");177 FALSE_RETURN_V_MSG_E(fd > 0, Status::ERROR_INVALID_DATA, "File descriptor is invalid");
178 178 
179- memFlag_ = static_cast<MemoryFlag>(parcel.ReadUint32());179+ uint32_t flagValue = parcel.ReadUint32();
180+ if (flagValue != static_cast<uint32_t>(MemoryFlag::MEMORY_READ_ONLY) &&
181+ flagValue != static_cast<uint32_t>(MemoryFlag::MEMORY_WRITE_ONLY) &&
182+ flagValue != static_cast<uint32_t>(MemoryFlag::MEMORY_READ_WRITE)) {
183+ MEDIA_LOG_E("invalid memFlag:%{public}u", flagValue);
184+ (void)::close(fd);
185+ return Status::ERROR_INVALID_DATA;
186+ }
187+ memFlag_ = static_cast<MemoryFlag>(flagValue);
180 188 
181 allocator_ = AVAllocatorFactory::CreateHardwareAllocator(fd, capacity_, memFlag_);189 allocator_ = AVAllocatorFactory::CreateHardwareAllocator(fd, capacity_, memFlag_);
182 if (allocator_ == nullptr) {190 if (allocator_ == nullptr) {
Msrc/buffer/avbuffer/av_shared_memory_ext.cpp+16-5
@@ -92,8 +92,10 @@ Status AVSharedMemoryExt::Init()
92{92{
93 memFlag_ = std::static_pointer_cast<AVSharedAllocator>(allocator_)->GetMemFlag();93 memFlag_ = std::static_pointer_cast<AVSharedAllocator>(allocator_)->GetMemFlag();
94 94 
95- int32_t allocSize = align_ ? (capacity_ + align_ - 1) : capacity_;95+ if (align_ > 0) {
96- fd_ = reinterpret_cast<intptr_t>(allocator_->Alloc(allocSize));96+ capacity_ = static_cast<int32_t>((static_cast<int64_t>(capacity_) + align_ - 1) / align_ * align_);
97+ }
98+ fd_ = reinterpret_cast<intptr_t>(allocator_->Alloc(capacity_));
97 FALSE_RETURN_V_MSG_E(fd_ > 0, Status::ERROR_NO_MEMORY, "Alloc AVSharedMemoryExt failed");99 FALSE_RETURN_V_MSG_E(fd_ > 0, Status::ERROR_NO_MEMORY, "Alloc AVSharedMemoryExt failed");
98 100 
99 uintptr_t addrBase = reinterpret_cast<uintptr_t>(base_);101 uintptr_t addrBase = reinterpret_cast<uintptr_t>(base_);
@@ -110,7 +112,12 @@ Status AVSharedMemoryExt::Init(MessageParcel &parcel)
110 }112 }
111 fd_ = parcel.ReadFileDescriptor();113 fd_ = parcel.ReadFileDescriptor();
112 FALSE_RETURN_V_MSG_E(fd_ > 0, Status::ERROR_INVALID_DATA, "File descriptor is invalid");114 FALSE_RETURN_V_MSG_E(fd_ > 0, Status::ERROR_INVALID_DATA, "File descriptor is invalid");
113- memFlag_ = static_cast<MemoryFlag>(parcel.ReadUint32());115+ uint32_t flagValue = parcel.ReadUint32();
116+ FALSE_RETURN_V_MSG_E(flagValue == static_cast<uint32_t>(MemoryFlag::MEMORY_READ_ONLY) ||
117+ flagValue == static_cast<uint32_t>(MemoryFlag::MEMORY_WRITE_ONLY) ||
118+ flagValue == static_cast<uint32_t>(MemoryFlag::MEMORY_READ_WRITE),
119+ Status::ERROR_INVALID_DATA, "invalid memFlag:%{public}u", flagValue);
120+ memFlag_ = static_cast<MemoryFlag>(flagValue);
114 return Status::OK;121 return Status::OK;
115#else122#else
116 return Status::OK;123 return Status::OK;
@@ -193,12 +200,16 @@ Status AVSharedMemoryExt::MapMemoryAddr()
193 ON_SCOPE_EXIT(0)200 ON_SCOPE_EXIT(0)
194 {201 {
195 MEDIA_LOG_E("create avsharedmemory failed. "202 MEDIA_LOG_E("create avsharedmemory failed. "
196- "size:%{public}d, flags:0x%{public}x, fd:%{public}d",203+ "capacity:%{public}d, flags:0x%{public}x, fd:%{public}d",
197 capacity_, memFlag_, fd_);204 capacity_, memFlag_, fd_);
198 UnMapMemoryAddr();205 UnMapMemoryAddr();
199 return Status::ERROR_NO_MEMORY;206 return Status::ERROR_NO_MEMORY;
200 };207 };
201- FALSE_RETURN_V_MSG_E(capacity_ > 0, Status::ERROR_INVALID_DATA, "size is invalid, size:%{public}d", capacity_);208+ FALSE_RETURN_V_MSG_E(capacity_ > 0, Status::ERROR_INVALID_DATA, "capacity is invalid");
209+ FALSE_RETURN_V_MSG_E(fd_ > 0, Status::ERROR_INVALID_DATA, "fd is invalid");
210+ int ashmemSize = AshmemGetSize(fd_);
211+ FALSE_RETURN_V_MSG_E(ashmemSize == capacity_, Status::ERROR_INVALID_DATA,
212+ "AshmemGetSize not equal capacity, ashmemSize:%{public}d", ashmemSize);
202 unsigned int prot = PROT_READ | PROT_WRITE;213 unsigned int prot = PROT_READ | PROT_WRITE;
203 if (memFlag_ == MemoryFlag::MEMORY_READ_ONLY) {214 if (memFlag_ == MemoryFlag::MEMORY_READ_ONLY) {
204 prot &= ~PROT_WRITE;215 prot &= ~PROT_WRITE;
Msrc/buffer/avbuffer/av_virtual_memory.cpp+4-4
@@ -71,12 +71,12 @@ AVVirtualMemory::~AVVirtualMemory()
71 71 
72Status AVVirtualMemory::Init()72Status AVVirtualMemory::Init()
73{73{
74- int32_t allocSize = align_ ? (capacity_ + align_ - 1) : capacity_;74+ if (align_ > 0) {
75- base_ = static_cast<uint8_t *>(allocator_->Alloc(allocSize));75+ capacity_ = static_cast<int32_t>((static_cast<int64_t>(capacity_) + align_ - 1) / align_ * align_);
76+ }
77+ base_ = static_cast<uint8_t *>(allocator_->Alloc(capacity_));
76 FALSE_RETURN_V_MSG_E(base_ != nullptr, Status::ERROR_NO_MEMORY, "Alloc AVVirtualMemory failed");78 FALSE_RETURN_V_MSG_E(base_ != nullptr, Status::ERROR_NO_MEMORY, "Alloc AVVirtualMemory failed");
77 79 
78- uintptr_t addrBase = reinterpret_cast<uintptr_t>(base_);
79- offset_ = static_cast<int32_t>(AlignUp(addrBase, static_cast<uintptr_t>(offset_)) - addrBase);
80 return Status::OK;80 return Status::OK;
81}81}
82 82 
Msrc/buffer/avbuffer/avmemory.cpp+0-8
@@ -197,8 +197,6 @@ bool AVMemory::ReadCommonFromMessageParcel(MessageParcel &parcel)
197 197 
198 ret = parcel.ReadInt32(size);198 ret = parcel.ReadInt32(size);
199 FALSE_RETURN_V_MSG_E(ret && (capacity >= size) && (size >= 0), false, "size is invalid");199 FALSE_RETURN_V_MSG_E(ret && (capacity >= size) && (size >= 0), false, "size is invalid");
200- FALSE_RETURN_V_MSG_E(offset <= (INT32_MAX - size) && (size + offset) <= capacity, false,
201- "size + offset is invalid");
202 200 
203 capacity_ = capacity;201 capacity_ = capacity;
204 align_ = align;202 align_ = align;
@@ -223,8 +221,6 @@ bool AVMemory::SkipCommonFromMessageParcel(MessageParcel &parcel)
223 221 
224 ret = parcel.ReadInt32(size);222 ret = parcel.ReadInt32(size);
225 FALSE_RETURN_V_MSG_E(ret && (capacity_ >= size) && (size >= 0), false, "size is invalid");223 FALSE_RETURN_V_MSG_E(ret && (capacity_ >= size) && (size >= 0), false, "size is invalid");
226- FALSE_RETURN_V_MSG_E(offset <= (INT32_MAX - size) && (size + offset) <= capacity_, false,
227- "size + offset is invalid");
228 224 
229 size_ = size;225 size_ = size;
230 offset_ = offset;226 offset_ = offset;
@@ -276,8 +272,6 @@ Status AVMemory::SetSize(int32_t size)
276 "size out of range, "272 "size out of range, "
277 "current size:%{public}d , capacity:%{public}d",273 "current size:%{public}d , capacity:%{public}d",
278 size_, capacity_);274 size_, capacity_);
279- FALSE_RETURN_V_MSG_E(offset_ <= (INT32_MAX - size) && (size + offset_) <= capacity_,
280- Status::ERROR_INVALID_PARAMETER, "size + offset is invalid");
281 size_ = size;275 size_ = size;
282 return Status::OK;276 return Status::OK;
283}277}
@@ -293,8 +287,6 @@ Status AVMemory::SetOffset(int32_t offset)
293 "offset out of range, "287 "offset out of range, "
294 "current offset:%{public}d , capacity:%{public}d",288 "current offset:%{public}d , capacity:%{public}d",
295 offset_, capacity_);289 offset_, capacity_);
296- FALSE_RETURN_V_MSG_E(offset <= (INT32_MAX - size_) && (size_ + offset) <= capacity_,
297- Status::ERROR_INVALID_PARAMETER, "size + offset is invalid");
298 offset_ = offset;290 offset_ = offset;
299 return Status::OK;291 return Status::OK;
300}292}
Mtests/unittest/avbuffer/avbuffer_framework_unit_test.cpp+5-5
@@ -107,7 +107,7 @@ HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_SetBufferAttr_001, TestSize.Level1)
107{107{
108 OH_AVCodecBufferAttr attr;108 OH_AVCodecBufferAttr attr;
109 attr.pts = DEFAULT_PTS;109 attr.pts = DEFAULT_PTS;
110- attr.size = MEMSIZE - DEFAULT_OFFSET;110+ attr.size = MEMSIZE;
111 attr.offset = DEFAULT_OFFSET;111 attr.offset = DEFAULT_OFFSET;
112 attr.flags = DEFAULT_FLAG;112 attr.flags = DEFAULT_FLAG;
113 EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->SetBufferAttr(attr));113 EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->SetBufferAttr(attr));
@@ -282,7 +282,7 @@ HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetAndGetBufferAttr_001, TestS
282 auto buffer = OH_AVBuffer_Create(MEMSIZE);282 auto buffer = OH_AVBuffer_Create(MEMSIZE);
283 ASSERT_NE(buffer, nullptr);283 ASSERT_NE(buffer, nullptr);
284 OH_AVCodecBufferAttr attr;284 OH_AVCodecBufferAttr attr;
285- attr.size = MEMSIZE - DEFAULT_OFFSET;285+ attr.size = MEMSIZE;
286 attr.offset = DEFAULT_OFFSET;286 attr.offset = DEFAULT_OFFSET;
287 attr.pts = DEFAULT_PTS;287 attr.pts = DEFAULT_PTS;
288 attr.flags = DEFAULT_FLAG;288 attr.flags = DEFAULT_FLAG;
@@ -290,7 +290,7 @@ HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetAndGetBufferAttr_001, TestS
290 290 
291 OH_AVCodecBufferAttr getAttr;291 OH_AVCodecBufferAttr getAttr;
292 EXPECT_EQ(AV_ERR_OK, OH_AVBuffer_GetBufferAttr(buffer, &getAttr));292 EXPECT_EQ(AV_ERR_OK, OH_AVBuffer_GetBufferAttr(buffer, &getAttr));
293- EXPECT_EQ(getAttr.size, MEMSIZE - DEFAULT_OFFSET);293+ EXPECT_EQ(getAttr.size, MEMSIZE);
294 EXPECT_EQ(getAttr.offset, DEFAULT_OFFSET);294 EXPECT_EQ(getAttr.offset, DEFAULT_OFFSET);
295 EXPECT_EQ(getAttr.pts, DEFAULT_PTS);295 EXPECT_EQ(getAttr.pts, DEFAULT_PTS);
296 EXPECT_EQ(getAttr.flags, DEFAULT_FLAG);296 EXPECT_EQ(getAttr.flags, DEFAULT_FLAG);
@@ -332,7 +332,7 @@ HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetAndGetBufferAttr_003, TestS
332 ASSERT_NE(buffer, nullptr);332 ASSERT_NE(buffer, nullptr);
333 for (int32_t i = 0; i < TEST_LOOP_DEPTH; ++i) {333 for (int32_t i = 0; i < TEST_LOOP_DEPTH; ++i) {
334 OH_AVCodecBufferAttr attr;334 OH_AVCodecBufferAttr attr;
335- attr.size = MEMSIZE - DEFAULT_OFFSET;335+ attr.size = MEMSIZE;
336 attr.offset = DEFAULT_OFFSET;336 attr.offset = DEFAULT_OFFSET;
337 attr.pts = DEFAULT_PTS;337 attr.pts = DEFAULT_PTS;
338 attr.flags = DEFAULT_FLAG;338 attr.flags = DEFAULT_FLAG;
@@ -340,7 +340,7 @@ HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetAndGetBufferAttr_003, TestS
340 340 
341 OH_AVCodecBufferAttr getAttr;341 OH_AVCodecBufferAttr getAttr;
342 EXPECT_EQ(AV_ERR_OK, OH_AVBuffer_GetBufferAttr(buffer, &getAttr));342 EXPECT_EQ(AV_ERR_OK, OH_AVBuffer_GetBufferAttr(buffer, &getAttr));
343- EXPECT_EQ(getAttr.size, MEMSIZE - DEFAULT_OFFSET);343+ EXPECT_EQ(getAttr.size, MEMSIZE);
344 EXPECT_EQ(getAttr.offset, DEFAULT_OFFSET);344 EXPECT_EQ(getAttr.offset, DEFAULT_OFFSET);
345 EXPECT_EQ(getAttr.pts, DEFAULT_PTS);345 EXPECT_EQ(getAttr.pts, DEFAULT_PTS);
346 EXPECT_EQ(getAttr.flags, DEFAULT_FLAG);346 EXPECT_EQ(getAttr.flags, DEFAULT_FLAG);
Mtests/unittest/avbuffer/avbuffer_func_unit_test.cpp+0-246
@@ -2006,252 +2006,6 @@ HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_ReadFromMessageParcel_001
2006 CreateRemoteHardwareMem();2006 CreateRemoteHardwareMem();
2007 CheckAttrTrans();2007 CheckAttrTrans();
2008}2008}
2009- 
2010-/**
2011- * @tc.name: AVBuffer_VirtualMemory_SetSize_SizePlusOffset_001
2012- * @tc.desc: SetSize accepted when size+offset equals capacity (boundary)
2013- * @tc.type: FUNC
2014- */
2015-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_SetSize_SizePlusOffset_001, TestSize.Level1)
2016-{
2017- capacity_ = MEMSIZE;
2018- align_ = 0;
2019- CreateLocalVirtualMem();
2020- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2021- auto &mem = *buffer_->memory_;
2022- EXPECT_EQ(Status::OK, mem.SetOffset(capacity_ / 2)); // 2: half capacity
2023- EXPECT_EQ(mem.offset_, capacity_ / 2);
2024- EXPECT_EQ(Status::OK, mem.SetSize(capacity_ / 2)); // 2: size+offset == capacity
2025- EXPECT_EQ(mem.size_, capacity_ / 2);
2026-}
2027- 
2028-/**
2029- * @tc.name: AVBuffer_VirtualMemory_SetSize_SizePlusOffset_002
2030- * @tc.desc: SetSize rejected when size+offset exceeds capacity
2031- * @tc.type: FUNC
2032- */
2033-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_SetSize_SizePlusOffset_002, TestSize.Level1)
2034-{
2035- capacity_ = MEMSIZE;
2036- align_ = 0;
2037- CreateLocalVirtualMem();
2038- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2039- auto &mem = *buffer_->memory_;
2040- ASSERT_EQ(Status::OK, mem.SetOffset(capacity_ / 2)); // 2: half capacity
2041- int32_t oldSize = mem.size_;
2042- EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, mem.SetSize(capacity_ / 2 + 1)); // 2: sum > capacity
2043- EXPECT_EQ(mem.size_, oldSize); // unchanged on rejection
2044-}
2045- 
2046-/**
2047- * @tc.name: AVBuffer_VirtualMemory_SetSize_SizePlusOffset_003
2048- * @tc.desc: SetSize rejected when size+offset would overflow int32
2049- * @tc.type: FUNC
2050- */
2051-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_SetSize_SizePlusOffset_003, TestSize.Level1)
2052-{
2053- capacity_ = MEMSIZE;
2054- align_ = 0;
2055- CreateLocalVirtualMem();
2056- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2057- auto &mem = *buffer_->memory_;
2058- mem.offset_ = INT32_MAX; // force offset_ to INT32_MAX; size=1 makes size+offset overflow int32
2059- int32_t oldSize = mem.size_;
2060- EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, mem.SetSize(1));
2061- EXPECT_EQ(mem.size_, oldSize); // unchanged on rejection
2062-}
2063- 
2064-/**
2065- * @tc.name: AVBuffer_VirtualMemory_SetOffset_SizePlusOffset_001
2066- * @tc.desc: SetOffset accepted when size+offset equals capacity (boundary)
2067- * @tc.type: FUNC
2068- */
2069-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_SetOffset_SizePlusOffset_001, TestSize.Level1)
2070-{
2071- capacity_ = MEMSIZE;
2072- align_ = 0;
2073- CreateLocalVirtualMem();
2074- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2075- auto &mem = *buffer_->memory_;
2076- EXPECT_EQ(Status::OK, mem.SetSize(capacity_ / 2)); // 2: half capacity
2077- EXPECT_EQ(mem.size_, capacity_ / 2);
2078- EXPECT_EQ(Status::OK, mem.SetOffset(capacity_ / 2)); // 2: size+offset == capacity
2079- EXPECT_EQ(mem.offset_, capacity_ / 2);
2080-}
2081- 
2082-/**
2083- * @tc.name: AVBuffer_VirtualMemory_SetOffset_SizePlusOffset_002
2084- * @tc.desc: SetOffset rejected when size+offset exceeds capacity
2085- * @tc.type: FUNC
2086- */
2087-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_SetOffset_SizePlusOffset_002, TestSize.Level1)
2088-{
2089- capacity_ = MEMSIZE;
2090- align_ = 0;
2091- CreateLocalVirtualMem();
2092- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2093- auto &mem = *buffer_->memory_;
2094- ASSERT_EQ(Status::OK, mem.SetSize(capacity_ / 2)); // 2: half capacity
2095- int32_t oldOffset = mem.offset_;
2096- EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, mem.SetOffset(capacity_ / 2 + 1)); // 2: sum > capacity
2097- EXPECT_EQ(mem.offset_, oldOffset); // unchanged on rejection
2098-}
2099- 
2100-/**
2101- * @tc.name: AVBuffer_VirtualMemory_SetOffset_SizePlusOffset_003
2102- * @tc.desc: SetOffset rejected when size+offset would overflow int32
2103- * @tc.type: FUNC
2104- */
2105-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_SetOffset_SizePlusOffset_003, TestSize.Level1)
2106-{
2107- capacity_ = MEMSIZE;
2108- align_ = 0;
2109- CreateLocalVirtualMem();
2110- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2111- auto &mem = *buffer_->memory_;
2112- mem.size_ = INT32_MAX; // force size_ to INT32_MAX; offset=1 makes size+offset overflow int32
2113- int32_t oldOffset = mem.offset_;
2114- EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, mem.SetOffset(1));
2115- EXPECT_EQ(mem.offset_, oldOffset); // unchanged on rejection
2116-}
2117- 
2118-/**
2119- * @tc.name: AVBuffer_VirtualMemory_ReadCommon_SizePlusOffset_001
2120- * @tc.desc: ReadCommonFromMessageParcel accepted when size+offset equals capacity
2121- * @tc.type: FUNC
2122- */
2123-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_ReadCommon_SizePlusOffset_001, TestSize.Level1)
2124-{
2125- capacity_ = MEMSIZE;
2126- align_ = 0;
2127- CreateLocalVirtualMem();
2128- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2129- auto &mem = *buffer_->memory_;
2130- MessageParcel parcel;
2131- (void)parcel.WriteInt32(MEMSIZE); // capacity
2132- (void)parcel.WriteInt32(0); // align
2133- (void)parcel.WriteInt32(MEMSIZE / 2); // 2: offset, half capacity
2134- (void)parcel.WriteInt32(MEMSIZE / 2); // 2: size, sum == capacity
2135- EXPECT_TRUE(mem.ReadCommonFromMessageParcel(parcel));
2136- EXPECT_EQ(mem.capacity_, MEMSIZE);
2137- EXPECT_EQ(mem.offset_, MEMSIZE / 2);
2138- EXPECT_EQ(mem.size_, MEMSIZE / 2);
2139-}
2140- 
2141-/**
2142- * @tc.name: AVBuffer_VirtualMemory_ReadCommon_SizePlusOffset_002
2143- * @tc.desc: ReadCommonFromMessageParcel rejected when size+offset exceeds capacity
2144- * @tc.type: FUNC
2145- */
2146-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_ReadCommon_SizePlusOffset_002, TestSize.Level1)
2147-{
2148- capacity_ = MEMSIZE;
2149- align_ = 0;
2150- CreateLocalVirtualMem();
2151- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2152- auto &mem = *buffer_->memory_;
2153- int32_t oldCap = mem.capacity_;
2154- MessageParcel parcel;
2155- (void)parcel.WriteInt32(MEMSIZE); // capacity
2156- (void)parcel.WriteInt32(0); // align
2157- (void)parcel.WriteInt32(MEMSIZE / 2); // 2: offset, half capacity
2158- (void)parcel.WriteInt32(MEMSIZE / 2 + 1); // 2: size, sum > capacity
2159- EXPECT_FALSE(mem.ReadCommonFromMessageParcel(parcel));
2160- EXPECT_EQ(mem.capacity_, oldCap); // unchanged on rejection
2161-}
2162- 
2163-/**
2164- * @tc.name: AVBuffer_VirtualMemory_ReadCommon_SizePlusOffset_003
2165- * @tc.desc: ReadCommonFromMessageParcel rejected when size+offset would overflow int32
2166- * @tc.type: FUNC
2167- */
2168-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_ReadCommon_SizePlusOffset_003, TestSize.Level1)
2169-{
2170- capacity_ = MEMSIZE;
2171- align_ = 0;
2172- CreateLocalVirtualMem();
2173- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2174- auto &mem = *buffer_->memory_;
2175- int32_t oldCap = mem.capacity_;
2176- MessageParcel parcel;
2177- (void)parcel.WriteInt32(INT32_MAX); // capacity
2178- (void)parcel.WriteInt32(0); // align
2179- (void)parcel.WriteInt32(INT32_MAX); // offset
2180- (void)parcel.WriteInt32(1); // size, INT32_MAX + 1 overflows int32
2181- EXPECT_FALSE(mem.ReadCommonFromMessageParcel(parcel));
2182- EXPECT_EQ(mem.capacity_, oldCap); // unchanged on rejection
2183-}
2184- 
2185-/**
2186- * @tc.name: AVBuffer_VirtualMemory_SkipCommon_SizePlusOffset_001
2187- * @tc.desc: SkipCommonFromMessageParcel accepted when size+offset equals capacity
2188- * @tc.type: FUNC
2189- */
2190-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_SkipCommon_SizePlusOffset_001, TestSize.Level1)
2191-{
2192- capacity_ = MEMSIZE;
2193- align_ = 0;
2194- CreateLocalVirtualMem();
2195- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2196- auto &mem = *buffer_->memory_;
2197- MessageParcel parcel;
2198- (void)parcel.WriteInt32(MEMSIZE); // capacity (skipped)
2199- (void)parcel.WriteInt32(0); // align (skipped)
2200- (void)parcel.WriteInt32(MEMSIZE / 2); // 2: offset
2201- (void)parcel.WriteInt32(MEMSIZE / 2); // 2: size, sum == capacity_
2202- EXPECT_TRUE(mem.SkipCommonFromMessageParcel(parcel));
2203- EXPECT_EQ(mem.offset_, MEMSIZE / 2);
2204- EXPECT_EQ(mem.size_, MEMSIZE / 2);
2205-}
2206- 
2207-/**
2208- * @tc.name: AVBuffer_VirtualMemory_SkipCommon_SizePlusOffset_002
2209- * @tc.desc: SkipCommonFromMessageParcel rejected when size+offset exceeds capacity
2210- * @tc.type: FUNC
2211- */
2212-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_SkipCommon_SizePlusOffset_002, TestSize.Level1)
2213-{
2214- capacity_ = MEMSIZE;
2215- align_ = 0;
2216- CreateLocalVirtualMem();
2217- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2218- auto &mem = *buffer_->memory_;
2219- int32_t oldSize = mem.size_;
2220- int32_t oldOffset = mem.offset_;
2221- MessageParcel parcel;
2222- (void)parcel.WriteInt32(MEMSIZE); // capacity (skipped)
2223- (void)parcel.WriteInt32(0); // align (skipped)
2224- (void)parcel.WriteInt32(MEMSIZE / 2); // 2: offset
2225- (void)parcel.WriteInt32(MEMSIZE / 2 + 1); // 2: size, sum > capacity_
2226- EXPECT_FALSE(mem.SkipCommonFromMessageParcel(parcel));
2227- EXPECT_EQ(mem.size_, oldSize); // unchanged on rejection
2228- EXPECT_EQ(mem.offset_, oldOffset); // unchanged on rejection
2229-}
2230- 
2231-/**
2232- * @tc.name: AVBuffer_VirtualMemory_SkipCommon_SizePlusOffset_003
2233- * @tc.desc: SkipCommonFromMessageParcel rejected when size+offset would overflow int32
2234- * @tc.type: FUNC
2235- */
2236-HWTEST_F(AVBufferInnerUnitTest, AVBuffer_VirtualMemory_SkipCommon_SizePlusOffset_003, TestSize.Level1)
2237-{
2238- capacity_ = MEMSIZE;
2239- align_ = 0;
2240- CreateLocalVirtualMem();
2241- ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
2242- auto &mem = *buffer_->memory_;
2243- mem.capacity_ = INT32_MAX; // enlarge capacity_ so prior capacity_ >= offset/size pass
2244- int32_t oldSize = mem.size_;
2245- int32_t oldOffset = mem.offset_;
2246- MessageParcel parcel;
2247- (void)parcel.WriteInt32(0); // capacity (skipped)
2248- (void)parcel.WriteInt32(0); // align (skipped)
2249- (void)parcel.WriteInt32(INT32_MAX); // offset
2250- (void)parcel.WriteInt32(1); // size, INT32_MAX + 1 overflows int32
2251- EXPECT_FALSE(mem.SkipCommonFromMessageParcel(parcel));
2252- EXPECT_EQ(mem.size_, oldSize); // unchanged on rejection
2253- EXPECT_EQ(mem.offset_, oldOffset); // unchanged on rejection
2254-}
2255} // namespace AVBufferUT2009} // namespace AVBufferUT
2256} // namespace Media2010} // namespace Media
2257} // namespace OHOS2011} // namespace OHOS
Mtests/unittest/avbuffer/avbuffer_unit_test.h+1-1
@@ -111,7 +111,7 @@ private:
111 std::shared_ptr<AVBuffer> remoteBuffer_ = nullptr;111 std::shared_ptr<AVBuffer> remoteBuffer_ = nullptr;
112 std::shared_ptr<Meta> meta_ = nullptr;112 std::shared_ptr<Meta> meta_ = nullptr;
113 std::shared_ptr<MessageParcel> parcel_ = nullptr;113 std::shared_ptr<MessageParcel> parcel_ = nullptr;
114- MemoryFlag memFlag_;114+ MemoryFlag memFlag_ = MemoryFlag::MEMORY_READ_WRITE;
115 int32_t capacity_ = MEMSIZE;115 int32_t capacity_ = MEMSIZE;
116 int32_t align_ = 0;116 int32_t align_ = 0;
117 int32_t dmaFd_ = -1;117 int32_t dmaFd_ = -1;