openharmony/telephony_cellular_data
1
0
Fork 0
mirror of https://github.com/openharmony/telephony_cellular_data.git synced 2026-08-25 09:04:03 -04:00
Code Issues Packages Projects Releases Wiki Activity

0~fix: modify fuzz

Browse Source 
Signed-off-by: liujiandong <liujiandong1@huawei.com>1~
This commit is contained in:
YOUR_NAME
2022-11-14 14:20:24 +08:00
parent 1138d4d8d9
commit 1f014dd81d
4 changed files with 237 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files
services/include/cellular_data_controller.h
+1 -1
View File
@@ -54,7 +54,7 @@ private:
void RegisterEvents();
void UnRegisterEvents();
void RegisterDatabaseObserver();
void UnRegisterDataObserver();
void UnRegisterDatabaseObserver();
private:
std::shared_ptr<CellularDataHandler> cellularDataHandler_;
services/src/cellular_data_controller.cpp
+21 -5
View File
@@ -37,7 +37,15 @@ CellularDataController::CellularDataController(std::shared_ptr<AppExecFwk::Event
CellularDataController::~CellularDataController()
{
UnRegisterEvents();
UnRegisterDataObserver();
UnRegisterDatabaseObserver();
if (netManagerListener_ != nullptr) {
auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
if (samgrProxy != nullptr) {
samgrProxy->UnSubscribeSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, netManagerListener_);
samgrProxy->UnSubscribeSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, netManagerListener_);
netManagerListener_ = nullptr;
}
}
}
void CellularDataController::Init()
@@ -46,9 +54,8 @@ void CellularDataController::Init()
matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
cellularDataHandler_ = std::make_shared<CellularDataHandler>(GetEventRunner(), subscriberInfo, slotId_);
cellularDataRdbObserver_ = std::make_unique<CellularDataRdbObserver>(cellularDataHandler_).release();
if (cellularDataHandler_ == nullptr || cellularDataRdbObserver_ == nullptr) {
TELEPHONY_LOGE("Slot%{public}d: cellularDataHandler_ or cellularDataRdbObserver_ is null", slotId_);
if (cellularDataHandler_ == nullptr) {
TELEPHONY_LOGE("Slot%{public}d: cellularDataHandler_ is null", slotId_);
return;
}
cellularDataHandler_->Init();
@@ -255,14 +262,23 @@ void CellularDataController::UnRegisterEvents()
TELEPHONY_LOGI("Slot%{public}d: UnRegisterEvents end", slotId_);
}
void CellularDataController::UnRegisterDataObserver()
void CellularDataController::UnRegisterDatabaseObserver()
{
if (cellularDataRdbObserver_ == nullptr) {
TELEPHONY_LOGE("Slot%{public}d: cellularDataRdbObserver_ is null", slotId_);
return;
}
std::shared_ptr<CellularDataRdbHelper> cellularDataDbHelper = CellularDataRdbHelper::GetInstance();
cellularDataDbHelper->UnRegisterObserver(cellularDataRdbObserver_);
}
void CellularDataController::RegisterDatabaseObserver()
{
cellularDataRdbObserver_ = std::make_unique<CellularDataRdbObserver>(cellularDataHandler_).release();
if (cellularDataRdbObserver_ == nullptr) {
TELEPHONY_LOGE("Slot%{public}d: cellularDataRdbObserver_ is null", slotId_);
return;
}
std::shared_ptr<CellularDataRdbHelper> cellularDataDbHelper = CellularDataRdbHelper::GetInstance();
cellularDataDbHelper->RegisterObserver(cellularDataRdbObserver_);
}
test/fuzztest/getcellulardatastate_fuzzer/BUILD.gn
+20 -2
View File
@@ -23,20 +23,38 @@ ohos_fuzztest("GetCellularDataStateFuzzTest") {
module_out_path = module_output_path
fuzz_config_file =
"//base/telephony/cellular_data/test/fuzztest/getcellulardatastate_fuzzer"
include_dirs =
[ "//base/telephony/cellular_data/test/fuzztest/common_fuzzer" ]
include_dirs = [
"//base/telephony/cellular_data/services/include",
"//base/telephony/cellular_data/services/include/apn_manager",
"//base/telephony/cellular_data/services/include/common",
"//base/telephony/cellular_data/services/include/state_machine",
"//base/telephony/cellular_data/services/include/utils",
"//base/telephony/cellular_data/test/fuzztest/common_fuzzer",
"//base/telephony/telephony_data/pdp_profile/include",
]
configs = [ "//base/telephony/core_service/utils:telephony_log_config" ]
deps = [ "//base/telephony/cellular_data:tel_cellular_data" ]
external_deps = [
"ability_runtime:ability_manager",
"ability_runtime:data_ability_helper",
"access_token:libaccesstoken_sdk",
"access_token:libnativetoken",
"access_token:libtoken_setproc",
"bundle_framework:appexecfwk_core",
"c_utils:utils",
"cellular_data:tel_cellular_data_api",
"common_event_service:cesfwk_innerkits",
"core_service:libtel_common",
"core_service:tel_core_service_api",
"eventhandler:libeventhandler",
"init:libbegetutil",
"netmanager_base:net_conn_manager_if",
"netmanager_base:net_policy_manager_if",
"netmanager_base:net_stats_manager_if",
"relational_store:native_rdb",
]
defines += [
test/fuzztest/getcellulardatastate_fuzzer/getcellulardatastate_fuzzer.cpp
+195 -14
View File
@@ -17,29 +17,210 @@
#include <cstddef>
#include <cstdint>
#define private public
#include "adddatatoken_fuzzer.h"
#include "cellular_data_client.h"
#include "cellular_data_service.h"
#include "cellular_data_service_stub.h"
#include "system_ability_definition.h"
using namespace OHOS::Telephony;
namespace OHOS {
void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
static bool g_isInited = false;
constexpr int32_t SLOT_NUM = 2;
bool IsServiceInited()
{
if (data == nullptr || size <= 0) {
if (!g_isInited) {
DelayedSingleton<CellularDataService>::GetInstance()->OnStart();
if (DelayedSingleton<CellularDataService>::GetInstance()->GetServiceRunningState() ==
static_cast<int32_t>(ServiceRunningState::STATE_RUNNING)) {
g_isInited = true;
}
}
return g_isInited;
}
void OnRemoteRequest(const uint8_t *data, size_t size)
{
if (!IsServiceInited()) {
return;
}
int32_t slotId = static_cast<int32_t>(size);
CellularDataClient::GetInstance().GetCellularDataState();
CellularDataClient::GetInstance().IsCellularDataEnabled();
CellularDataClient::GetInstance().IsCellularDataRoamingEnabled(slotId);
CellularDataClient::GetInstance().GetDefaultCellularDataSlotId();
CellularDataClient::GetInstance().EnableCellularDataRoaming(slotId, static_cast<int32_t>(size % 2));
CellularDataClient::GetInstance().SetDefaultCellularDataSlotId(slotId);
CellularDataClient::GetInstance().HasInternetCapability(slotId, size);
CellularDataClient::GetInstance().ClearCellularDataConnections(slotId);
CellularDataClient::GetInstance().GetCellularDataFlowType();
MessageParcel dataMessageParcel;
if (!dataMessageParcel.WriteInterfaceToken(CellularDataServiceStub::GetDescriptor())) {
return;
}
size_t dataSize = size - sizeof(uint32_t);
dataMessageParcel.WriteBuffer(data + sizeof(uint32_t), dataSize);
dataMessageParcel.RewindRead(0);
uint32_t code = static_cast<uint32_t>(size);
MessageParcel reply;
MessageOption option;
DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
}
void EnableCellularData(const uint8_t *data, size_t size)
{
if (!IsServiceInited()) {
return;
}
MessageParcel dataMessageParcel;
dataMessageParcel.WriteBuffer(data, size);
dataMessageParcel.RewindRead(0);
MessageParcel reply;
DelayedSingleton<CellularDataService>::GetInstance()->OnEnableCellularData(dataMessageParcel, reply);
}
void GetCellularDataState(const uint8_t *data, size_t size)
{
if (!IsServiceInited()) {
return;
}
MessageParcel dataMessageParcel;
dataMessageParcel.WriteBuffer(data, size);
dataMessageParcel.RewindRead(0);
MessageParcel reply;
DelayedSingleton<CellularDataService>::GetInstance()->OnGetCellularDataState(dataMessageParcel, reply);
}
void IsCellularDataEnabled(const uint8_t *data, size_t size)
{
if (!IsServiceInited()) {
return;
}
MessageParcel dataMessageParcel;
dataMessageParcel.WriteBuffer(data, size);
dataMessageParcel.RewindRead(0);
MessageParcel reply;
DelayedSingleton<CellularDataService>::GetInstance()->OnIsCellularDataEnabled(dataMessageParcel, reply);
}
void IsCellularDataRoamingEnabled(const uint8_t *data, size_t size)
{
if (!IsServiceInited()) {
return;
}
int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
MessageParcel dataMessageParcel;
dataMessageParcel.WriteInt32(slotId);
size_t dataSize = size - sizeof(int32_t);
dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
dataMessageParcel.RewindRead(0);
MessageParcel reply;
DelayedSingleton<CellularDataService>::GetInstance()->OnIsCellularDataRoamingEnabled(dataMessageParcel, reply);
}
void GetDefaultCellularDataSlotId(const uint8_t *data, size_t size)
{
if (!IsServiceInited()) {
return;
}
MessageParcel dataMessageParcel;
dataMessageParcel.WriteBuffer(data, size);
dataMessageParcel.RewindRead(0);
MessageParcel reply;
DelayedSingleton<CellularDataService>::GetInstance()->OnGetDefaultCellularDataSlotId(dataMessageParcel, reply);
}
void EnableCellularDataRoaming(const uint8_t *data, size_t size)
{
if (!IsServiceInited()) {
return;
}
int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
MessageParcel dataMessageParcel;
dataMessageParcel.WriteInt32(slotId);
size_t dataSize = size - sizeof(int32_t);
dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
dataMessageParcel.RewindRead(0);
MessageParcel reply;
DelayedSingleton<CellularDataService>::GetInstance()->OnEnableCellularDataRoaming(dataMessageParcel, reply);
}
void SetDefaultCellularDataSlotId(const uint8_t *data, size_t size)
{
if (!IsServiceInited()) {
return;
}
int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
MessageParcel dataMessageParcel;
dataMessageParcel.WriteInt32(slotId);
size_t dataSize = size - sizeof(int32_t);
dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
dataMessageParcel.RewindRead(0);
MessageParcel reply;
DelayedSingleton<CellularDataService>::GetInstance()->OnSetDefaultCellularDataSlotId(dataMessageParcel, reply);
}
void HasInternetCapability(const uint8_t *data, size_t size)
{
if (!IsServiceInited()) {
return;
}
int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
MessageParcel dataMessageParcel;
dataMessageParcel.WriteInt32(slotId);
size_t dataSize = size - sizeof(int32_t);
dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
dataMessageParcel.RewindRead(0);
MessageParcel reply;
DelayedSingleton<CellularDataService>::GetInstance()->OnHasInternetCapability(dataMessageParcel, reply);
}
void ClearCellularDataConnections(const uint8_t *data, size_t size)
{
if (!IsServiceInited()) {
return;
}
int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
MessageParcel dataMessageParcel;
dataMessageParcel.WriteInt32(slotId);
size_t dataSize = size - sizeof(int32_t);
dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
dataMessageParcel.RewindRead(0);
MessageParcel reply;
DelayedSingleton<CellularDataService>::GetInstance()->OnClearCellularDataConnections(dataMessageParcel, reply);
}
void GetCellularDataFlowType(const uint8_t *data, size_t size)
{
if (!IsServiceInited()) {
return;
}
MessageParcel dataMessageParcel;
dataMessageParcel.WriteBuffer(data, size);
dataMessageParcel.RewindRead(0);
MessageParcel reply;
DelayedSingleton<CellularDataService>::GetInstance()->OnGetCellularDataFlowType(dataMessageParcel, reply);
}
void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
{
if (data == nullptr || size == 0) {
return;
}
OnRemoteRequest(data, size);
EnableCellularData(data, size);
GetCellularDataState(data, size);
IsCellularDataEnabled(data, size);
IsCellularDataRoamingEnabled(data, size);
GetDefaultCellularDataSlotId(data, size);
GetCellularDataFlowType(data, size);
EnableCellularDataRoaming(data, size);
SetDefaultCellularDataSlotId(data, size);
HasInternetCapability(data, size);
ClearCellularDataConnections(data, size);
}
} // namespace OHOS