1/*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15#include "dump_utils.h"
16
17#include <cerrno>
18#include <csignal>
19#include <fcntl.h>
20#include <poll.h>
21#include <set>
22#include <map>
23#include <sys/stat.h>
24#include <sys/utsname.h>
25#include <unistd.h>
26#include <fstream>
27#include <iostream>
28
29#include <sys/prctl.h>
30#include <sys/resource.h>
31#include <sys/times.h>
32#include <sys/types.h>
33#include <sys/wait.h>
34
35#include "common.h"
36#include "datetime_ex.h"
37#include "file_ex.h"
38#include "iservice_registry.h"
39#include "parameters.h"
40#include "securec.h"
41#include "string_ex.h"
42
43#include "system_ability_definition.h"
44#include "hilog_wrapper.h"
45
46#ifdef HIDUMPER_BUNDLEMANAGER_FRAMEWORK_ENABLE
47#include "application_info.h"
48#include "bundlemgr/bundle_mgr_proxy.h"
49#endif
50
51namespace OHOS {
52inline const std::map<int, std::string> saNameMap_ = {
53    { 0, "SystemAbilityManager" },
54    { 200, "AccountMgr" },
55    { 301, "AIEngine" },
56    { ABILITY_MGR_SERVICE_ID, "AbilityManagerService" },
57    { DATAOBS_MGR_SERVICE_SA_ID, "DataObserverMgr" },
58    { APP_MGR_SERVICE_ID, "ApplicationManagerService" },
59    { URI_PERMISSION_MGR_SERVICE_ID, "UriPermissionMgr" },
60    { QUICK_FIX_MGR_SERVICE_ID, "QuickFixMgrService"},
61    { BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, "BundleMgr" },
62    { SERVICE_ROUTER_MGR_SERVICE_ID, "ServiceRouterMgr" },
63    { INSTALLD_SERVICE_ID, "Installd" },
64    { FORM_MGR_SERVICE_ID, "FormMgr" },
65    { WIFI_DEVICE_SYS_ABILITY_ID, "WifiDevice" },
66    { WIFI_HOTSPOT_SYS_ABILITY_ID, "WifiHotspot" },
67    { WIFI_ENHANCER_SYS_ABILITY_ID, "WifiEnhancer" },
68    { WIFI_P2P_SYS_ABILITY_ID, "WifiP2p" },
69    { WIFI_SCAN_SYS_ABILITY_ID, "WifiScan" },
70    { BLUETOOTH_HOST_SYS_ABILITY_ID, "BluetoothHost" },
71    { NFC_MANAGER_SYS_ABILITY_ID, "NfcManager" },
72    { SE_MANAGER_SYS_ABILITY_ID, "SeManager" },
73    { NET_MANAGER_SYS_ABILITY_ID, "NetManager" },
74    { DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "DistributedKvData" },
75    { DISTRIBUTED_SCHED_SA_ID, "DistributedSched" },
76    { DISTRIBUTED_SCHED_ADAPTER_SA_ID, "DistributedSchedAdapter" },
77    { DISTRIBUTED_SCENARIO_MGR_SA_ID, "DistributedScenarioMgr" },
78    { CONTINUATION_MANAGER_SA_ID, "ContinuationManagerService" },
79    { RES_SCHED_SYS_ABILITY_ID, "ResourceSched" },
80    { RESSCHEDD_SA_ID, "ResourceSchedDamon" },
81    { BACKGROUND_TASK_MANAGER_SERVICE_ID, "BackgroundTaskManager" },
82    { WORK_SCHEDULE_SERVICE_ID, "WorkSchedule" },
83    { CONCURRENT_TASK_SERVICE_ID, "ConcurrentTaskService" },
84    { RESOURCE_QUOTA_CONTROL_SYSTEM_ABILITY_ID, "ResourceQuotaControl"},
85    { DEVICE_STANDBY_SERVICE_SYSTEM_ABILITY_ID, "DeviceStandbyService"},
86    { TASK_HEARTBEAT_MGR_SYSTEM_ABILITY_ID, "TaskHeartbeatMgrService"},
87    { COMPONENT_SCHEDULE_SERVICE_ID, "ComponentSchedServer" },
88    { SOC_PERF_SERVICE_SA_ID, "SocPerfService" },
89    { SUSPEND_MANAGER_SYSTEM_ABILITY_ID, "SuspendManager" },
90    { APP_NAP_SYSTEM_ABILITY_ID, "AppNap" },
91    { ABNORMAL_EFFICIENCY_MGR_SYSTEM_ABILITY_ID, "AbnormalEfficiencyManager" },
92    { LOCATION_GEO_CONVERT_SA_ID, "LocationGeoConvert" },
93    { LOCATION_LOCATOR_SA_ID, "LocationLocator" },
94    { LOCATION_GNSS_SA_ID, "LocationGnss" },
95    { LOCATION_NETWORK_LOCATING_SA_ID, "LocationNetworkLocating" },
96    { LOCATION_NOPOWER_LOCATING_SA_ID, "LocationNopowerLocating" },
97    { AUDIO_DISTRIBUTED_SERVICE_ID, "AudioDistributed" },
98    { COMMON_EVENT_SERVICE_ABILITY_ID, "CommonEventService" },
99    { ADVANCED_NOTIFICATION_SERVICE_ABILITY_ID, "DistributedNotificationService" },
100    { COMMON_EVENT_SERVICE_ID, "CommonEventService" },
101    { POWER_MANAGER_SERVICE_ID, "PowerManagerService" },
102    { POWER_MANAGER_BATT_SERVICE_ID, "BatteryService" },
103    { POWER_MANAGER_BATT_STATS_SERVICE_ID, "BatteryStatisticsService" },
104    { POWER_MANAGER_THERMAL_SERVICE_ID, "ThermalService" },
105    { DISPLAY_MANAGER_SERVICE_ID, "DisplayPowerManagerService" },
106    { 3502, "DpmsService" },
107    { 3510, "KeystoreService" },
108    { DEVICE_SECURITY_LEVEL_MANAGER_SA_ID, "DslmService" },
109    { CERT_MANAGER_SERVICE_SA_ID, "CertManagerService"},
110    { DEVICE_THREAT_DETECTION_SERVICE_SA_ID, "DeviceThreatDetectionService" },
111    { SENSOR_SERVICE_ABILITY_ID, "SensorService" },
112    { MISCDEVICE_SERVICE_ABILITY_ID, "MiscDeviceService" },
113    { PASTEBOARD_SERVICE_ID, "PasteboardService" },
114    { SCREENLOCK_SERVICE_ID, "ScreenlockService" },
115    { WALLPAPER_MANAGER_SERVICE_ID, "WallpaperManagerService" },
116    { PRINT_SERVICE_ID, "PrintFramework" },
117    { SCAN_SERVICE_ID, "ScanFramework" },
118    { TELEPHONY_SYS_ABILITY_ID, "Telephony" },
119    { DCALL_SYS_ABILITY_ID, "DistributedCallMgr" },
120    { TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID, "TelephonyCallManager" },
121    { TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID, "TelephonyCellularCall" },
122    { TELEPHONY_CELLULAR_DATA_SYS_ABILITY_ID, "TelephonyCellularData" },
123    { TELEPHONY_SMS_MMS_SYS_ABILITY_ID, "TelephonySmsMms" },
124    { TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID, "TelephonyStateRegistry" },
125    { TELEPHONY_CORE_SERVICE_SYS_ABILITY_ID, "TelephonyCoreService" },
126    { TELEPHONY_DATA_STORAGE_SYS_ABILITY_ID, "TelephonyDataStorage" },
127    { TELEPHONY_IMS_SYS_ABILITY_ID, "TelephonyIms" },
128    { DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID, "DeviceManagerService" },
129    { DISTRIBUTED_HARDWARE_SA_ID, "DistributedHardwareFramework" },
130    { DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, "DistributedCameraSourceService" },
131    { DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, "DistributedCameraSinkService" },
132    { DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID, "DistributedAudioSourceService" },
133    { DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, "DistributedAudioSinkService" },
134    { DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, "DistributedScreenSourceService" },
135    { DISTRIBUTED_HARDWARE_SCREEN_SINK_SA_ID, "DistributedScreenSinkService" },
136    { DISTRIBUTED_HARDWARE_INPUT_SOURCE_SA_ID, "DistributedInputSourceService" },
137    { DISTRIBUTED_HARDWARE_INPUT_SINK_SA_ID, "DistributedInputSinkService" },
138    { INPUT_METHOD_SYSTEM_ABILITY_ID, "InputMethodService" },
139    { MEDICAL_SENSOR_SERVICE_ABILITY_ID, "MedicalSensorService" },
140    { USB_SYSTEM_ABILITY_ID, "UsbService" },
141    { STORAGE_MANAGER_DAEMON_ID, "StorageDaemon" },
142    { STORAGE_MANAGER_MANAGER_ID, "StorageManager"},
143    { FILEMANAGEMENT_DISTRIBUTED_FILE_DAEMON_SA_ID, "DistributedFileDaemon"},
144    { FILEMANAGEMENT_CLOUD_SYNC_SERVICE_SA_ID, "CloudFileSyncService"},
145    { FILEMANAGEMENT_CLOUD_DAEMON_SERVICE_SA_ID, "CloudFileDaemonService"},
146    { DEVICE_SERVICE_MANAGER_SA_ID, "HdfDeviceServiceManager" },
147    { HDF_EXTERNAL_DEVICE_MANAGER_SA_ID, "HdfExternalDeviceManager" },
148    { DISTRIBUTED_DEVICE_PROFILE_SA_ID, "DistributedDeviceProfile" },
149    { WINDOW_MANAGER_SERVICE_ID, "WindowManagerService" },
150    { DISPLAY_MANAGER_SERVICE_SA_ID, "DisplayManagerService" },
151    { SOFTBUS_SERVER_SA_ID, "DSoftbus" },
152    { DEVICE_AUTH_SERVICE_ID, "DeviceAuthService" },
153    { WINDOW_MANAGER_ID, "WindowManager" },
154    { VSYNC_MANAGER_ID, "VsyncManager" },
155    { VSYNC_MANAGER_TEST_ID, "VsyncManagerTest" },
156    { GRAPHIC_DUMPER_SERVICE_SA_ID, "GraphicDumperService" },
157    { GRAPHIC_DUMPER_COMMAND_SA_ID, "GraphicDumperCommand" },
158    { ANIMATION_SERVER_SA_ID, "AnimationServer" },
159    { CA_DAEMON_ID, "CaDaemon" },
160    { ACCESSIBILITY_MANAGER_SERVICE_ID, "AccessibilityManagerService" },
161    { DEVICE_USAGE_STATISTICS_SYS_ABILITY_ID, "DeviceUsageStatistics" },
162    { MEMORY_MANAGER_SA_ID, "MemoryManagerService" },
163    { AVSESSION_SERVICE_ID, "AVSessionService" },
164    { SYS_INSTALLER_DISTRIBUTED_SERVICE_ID, "SysInstallerService" },
165    { MODULE_UPDATE_SERVICE_ID, "ModuleUpdateService" },
166    { SUBSYS_ACE_SYS_ABILITY_ID_BEGIN, "UiService" },
167    { ARKUI_UI_APPEARANCE_SERVICE_ID, "UiAppearanceService" },
168    { SUBSYS_USERIAM_SYS_ABILITY_USERIDM, "UserIdmService" },
169    { SUBSYS_USERIAM_SYS_ABILITY_AUTHEXECUTORMGR, "AuthExecutorMgrService" },
170    { RENDER_SERVICE, "RenderService" },
171    { ACCESS_TOKEN_MANAGER_SERVICE_ID, "AccessTokenManagerService" },
172    { TOKEN_SYNC_MANAGER_SERVICE_ID, "TokenSyncManagerService" },
173    { SANDBOX_MANAGER_SERVICE_ID, "SandboxManagerService" },
174    { DLP_PERMISSION_SERVICE_ID, "DlpPermissionService" },
175    { RISK_ANALYSIS_MANAGER_SA_ID, "RiskAnalysisManagerService" },
176    { DATA_COLLECT_MANAGER_SA_ID, "DataCollectManagerService" },
177    { MSDP_DEVICESTATUS_SERVICE_ID, "DeviceStatusService" },
178    { MULTIMODAL_INPUT_SERVICE_ID, "MultimodalInput" },
179    { DFX_SYS_HIVIEW_ABILITY_ID, "HiviewService" },
180    { PRIVACY_MANAGER_SERVICE_ID, "PrivacyManagerService"},
181    { DFX_FAULT_LOGGER_ABILITY_ID, "HiviewFaultLogger" },
182    { DFX_SYS_EVENT_SERVICE_ABILITY_ID, "HiviewSysEventService" },
183    { DFX_SYS_NATIVE_MEMORY_PROFILER_SERVICE_ABILITY_ID, "HiviewSysNativeMemoryProfilerService"},
184    { XPERF_SYS_TRACE_SERVICE_ABILITY_ID, "XperfTraceService" },
185    { XPERF_SYS_IO_SERVICE_ABILITY_ID, "XperfIoService" },
186    { XPERF_BIGDATA_MANAGER_SERVICE_ABILITY_ID, "XperfBigDataManagerService" },
187    { DFX_HI_DUMPER_SERVICE_ABILITY_ID, "HiDumperService" },
188    { XPOWER_MANAGER_SYSTEM_ABILITY_ID, "XpowerManager"},
189    { DFX_HI_PERF_SERVICE_ABILITY_ID, "HiPerfService"},
190    { DFX_HI_DUMPER_CPU_SERVICE_ABILITY_ID, "HiDumperCpuService" },
191    { SUBSYS_USERIAM_SYS_ABILITY_USERAUTH, "UserAuthService" },
192    { SUBSYS_USERIAM_SYS_ABILITY_PINAUTH, "PinAuthService" },
193    { SUBSYS_USERIAM_SYS_ABILITY_FACEAUTH, "FaceAuthService" },
194    { SUBSYS_USERIAM_SYS_ABILITY_FINGERPRINTAUTH, "FingerprintAuthService" },
195    { SUBSYS_USERIAM_SYS_ABILITY_FINGERPRINTAUTH_EX, "FingerprintAuthServiceEx" },
196    { NET_MANAGER_SYS_ABILITY_ID, "NetManager" },
197    { COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "NetConnManager" },
198    { COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "NetPolicyManager" },
199    { COMM_NET_STATS_MANAGER_SYS_ABILITY_ID, "NetStatsManager" },
200    { COMM_NET_TETHERING_MANAGER_SYS_ABILITY_ID, "NetTetheringManager" },
201    { COMM_VPN_MANAGER_SYS_ABILITY_ID, "VPNManager" },
202    { COMM_DNS_MANAGER_SYS_ABILITY_ID, "DNSManager"},
203    { COMM_ETHERNET_MANAGER_SYS_ABILITY_ID, "EthernetManager" },
204    { COMM_NETSYS_NATIVE_SYS_ABILITY_ID, "NetsysNative" },
205    { COMM_MDNS_MANAGER_SYS_ABILITY_ID, "MDNSManager"},
206    { COMM_NETSYS_EXT_SYS_ABILITY_ID, "NetsysExtService"},
207    { COMM_DISTRIBUTED_NET_ABILITY_ID, "DistributedNet"},
208    { COMM_WEARABLE_DISTRIBUTED_NET_ABILITY_ID, "WearableDistributedNet"},
209    { ENTERPRISE_DEVICE_MANAGER_SA_ID, "EnterpriseDeviceManagerService" },
210    { I18N_SA_ID, "I18nService" },
211    { PARAM_WATCHER_DISTRIBUTED_SERVICE_ID, "ParamWatcher" },
212    { SYSPARAM_DEVICE_SERVICE_ID, "SysParamDevice" },
213    { TIME_SERVICE_ID, "TimeService" },
214    { PLAYER_DISTRIBUTED_SERVICE_ID, "PlayerDistributedService"},
215    { AV_CODEC_SERVICE_ID, "AVCodecService"},
216    { CAMERA_SERVICE_ID, "CameraService"},
217    { MEDIA_KEY_SYSTEM_SERVICE_ID, "MediaKeySystemService"},
218    { AUDIO_POLICY_SERVICE_ID, "AudioPolicyService"},
219    { DLP_CREDENTIAL_SERVICE_ID, "DlpCreService"},
220    { QUICKFIX_ENGINE_SERVICE_ID, "QuickfixEngineService"},
221    { DEVICE_ATTEST_PROFILE_SA_ID, "devattest_service" },
222    { AIDISPATCHER_ENGINE_SERVICE, "AIDispatcherEngineService" },
223    { SECURITY_COMPONENT_SERVICE_ID, "SecurityComponentService" },
224    { ADVERTISING_SA_ID, "Advertising" },
225    { LOCAL_CODE_SIGN_SERVICE_ID, "LocalCodeSignService" },
226    { INTELL_VOICE_SERVICE_ID, "IntellVoiceService" },
227    { FILE_ACCESS_SERVICE_ID, "FileAccessService" },
228    { MSDP_USER_STATUS_SERVICE_ID, "UserStatusAwarenessService" },
229    { NEARLINK_HOST_SYS_ABILITY_ID, "NearLinkHost" },
230    { ECOLOGICAL_RULE_MANAGER_SA_ID, "EcologicalRuleManager" },
231    { ASSET_SERVICE_ID, "AssetService" },
232    { TEST_SERVER_SA_ID, "TestServer" },
233    { APP_DOMAIN_VERIFY_MANAGER_SA_ID, "AppDomainVerifyManager" },
234    { APP_DOMAIN_VERIFY_AGENT_SA_ID, "AppDomainVerifyAgent" },
235    { AOT_COMPILER_SERVICE_ID, "AotCompilerService" },
236    { EL5_FILEKEY_MANAGER_SERVICE_ID, "El5FilekeyManager"},
237    { COMM_FIREWALL_MANAGER_SYS_ABILITY_ID, "NetFirewallManager" },
238    { SUBSYS_WEBVIEW_SYS_UPDATE_SERVICE_ID, "AppFwkUpdateService"},
239};
240
241namespace HiviewDFX {
242void DumpUtils::IgnorePipeQuit()
243{
244    signal(SIGPIPE, SIG_IGN); // protect from pipe quit
245}
246
247void DumpUtils::IgnoreStdoutCache()
248{
249    setvbuf(stdout, nullptr, _IONBF, 0); // never cache stdout
250}
251
252void DumpUtils::IgnoreOom()
253{
254    setpriority(PRIO_PROCESS, 0, TOP_PRIORITY); // protect from OOM
255}
256
257void DumpUtils::SetAdj(int adj)
258{
259    int fd = FdToWrite(FILE_CUR_OOM_ADJ);
260    if (fd < 0) {
261        return;
262    }
263    dprintf(fd, "%d", adj);
264    close(fd);
265}
266
267void DumpUtils::BoostPriority()
268{
269    IgnoreOom();
270    IgnorePipeQuit();
271    IgnoreStdoutCache();
272    SetAdj(TOP_OOM_ADJ);
273}
274
275std::string DumpUtils::ErrnoToMsg(const int &error)
276{
277    const int bufSize = 128;
278    char buf[bufSize] = {0};
279    strerror_r(error, buf, bufSize);
280    return buf;
281}
282
283int DumpUtils::FdToRead(const std::string &file)
284{
285    char path[PATH_MAX] = {0};
286    if (realpath(file.c_str(), path) == nullptr) {
287        DUMPER_HILOGE(MODULE_COMMON, "realpath, no such file. path=[%{public}s], file=[%{public}s]",
288            path, file.c_str());
289        return -1;
290    }
291
292    if (file != std::string(path)) {
293        DUMPER_HILOGI(MODULE_COMMON, "fail to check consistency. path=[%{public}s], file=[%{public}s]",
294            path, file.c_str());
295    }
296
297    int fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC | O_NONBLOCK));
298    if (fd == -1) {
299        DUMPER_HILOGE(MODULE_COMMON, "open [%{public}s] %{public}s", path, ErrnoToMsg(errno).c_str());
300    }
301    return fd;
302}
303
304int DumpUtils::FdToWrite(const std::string &file)
305{
306    std::string split = "/";
307    auto pos = file.find_last_of(split);
308    if (pos == std::string::npos) {
309        DUMPER_HILOGE(MODULE_COMMON, "file path:[%{public}s] error", file.c_str());
310        return -1;
311    }
312    std::string tempPath = file.substr(0, pos + 1);
313    std::string name = file.substr(pos + 1);
314
315    char path[PATH_MAX] = {0};
316    if (realpath(tempPath.c_str(), path) != nullptr) {
317        std::string fileName = path + split + name;
318        int fd = -1;
319        if (access(fileName.c_str(), F_OK) == 0) {
320            fd = open(fileName.c_str(), O_WRONLY);
321            if (lseek(fd, 0, SEEK_END) == -1) {
322                DUMPER_HILOGE(MODULE_COMMON, "lseek fail fd:%{public}d, errno:%{public}d", fd, errno);
323            }
324        } else {
325            fd = TEMP_FAILURE_RETRY(open(fileName.c_str(), O_WRONLY | O_CREAT | O_CLOEXEC | O_NOFOLLOW,
326                                         S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
327        }
328        if (fd == -1) {
329            DUMPER_HILOGE(MODULE_COMMON, "open [%{public}s] %{public}s",
330                fileName.c_str(), ErrnoToMsg(errno).c_str());
331        }
332        return fd;
333    }
334    DUMPER_HILOGD(MODULE_COMMON, "realpath, no such file. path=[%{public}s], tempPath=[%{public}s]",
335        path, tempPath.c_str());
336    return -1;
337}
338
339bool DumpUtils::CheckProcessAlive(uint32_t pid)
340{
341    char path[PATH_MAX] = {0};
342    char pathPid[PATH_MAX] = {0};
343    int ret = sprintf_s(pathPid, PATH_MAX, "/proc/%u", pid);
344    if (ret < 0) {
345        return false;
346    }
347    if (realpath(pathPid, path) != nullptr) { // path exist
348        if (access(path, F_OK) == 0) {        // can be read
349            return true;
350        }
351    }
352    return false;
353}
354
355void DumpUtils::RemoveDuplicateString(std::vector<std::string> &strList)
356{
357    std::vector<std::string> tmpVtr;
358    std::set<std::string> tmpSet;
359    for (auto &it : strList) {
360        auto ret = tmpSet.insert(it);
361        if (ret.second) {
362            tmpVtr.push_back(it);
363        }
364    }
365    strList = tmpVtr;
366}
367
368int DumpUtils::StrToId(const std::string &name)
369{
370    int id = -1;
371    auto iter = std::find_if(saNameMap_.begin(), saNameMap_.end(), [&](const std::pair<int, std::string> &item) {
372        return name.compare(item.second) == 0;
373    });
374    if (iter == saNameMap_.end()) {
375        if (!StrToInt(name, id)) { // Decimal string
376            return -1; // invalid ability ID
377        }
378    } else {
379        id = iter->first;
380    }
381    return id;
382}
383
384std::string DumpUtils::ConvertSaIdToSaName(const std::string &saIdStr)
385{
386    int saId = StrToId(saIdStr);
387    auto iter = saNameMap_.find(saId);
388    if (iter == saNameMap_.end()) {
389        return saIdStr;
390    }
391    return iter->second;
392}
393
394bool DumpUtils::DirectoryExists(const std::string &path)
395{
396    struct stat fileInfo;
397    if (stat(path.c_str(), &fileInfo) == 0) {
398        return S_ISDIR(fileInfo.st_mode);
399    }
400    return false;
401}
402
403bool DumpUtils::PathIsValid(const std::string &path)
404{
405    return access(path.c_str(), F_OK) == 0;
406}
407
408bool DumpUtils::CopyFile(const std::string &src, const std::string &des)
409{
410    std::ifstream fin(src);
411    std::ofstream fout(des);
412    if ((!fin.is_open()) || (!fout.is_open())) {
413        return false;
414    }
415    fout << fin.rdbuf();
416    if (fout.fail()) {
417        fout.clear();
418    }
419    fout.flush();
420    return true;
421}
422
423bool DumpUtils::IsCommercialVersion()
424{
425    bool isCommercialVersion = OHOS::system::GetParameter("const.logsystem.versiontype", "unknown") == "commercial";
426    return isCommercialVersion;
427}
428
429bool DumpUtils::IsUserMode()
430{
431    std::string debugMode = "0";
432    debugMode = OHOS::system::GetParameter("const.debuggable", debugMode);
433    return debugMode == "0";
434}
435
436bool DumpUtils::CheckAppDebugVersion(int pid)
437{
438    if (pid <= 0) {
439        DUMPER_HILOGE(MODULE_COMMON, "AppDebugVersion pid %{public}d false", pid);
440        return false;
441    }
442    std::string bundleName;
443    std::string filePath = "/proc/" + std::to_string(pid) + "/cmdline";
444    if (!OHOS::LoadStringFromFile(filePath, bundleName)) {
445        DUMPER_HILOGE(MODULE_COMMON, "Get process name by pid %{public}d failed!", pid);
446        return false;
447    }
448    if (bundleName.empty()) {
449        DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d or process name is illegal!", pid);
450        return false;
451    }
452    auto pos = bundleName.find(":");
453    if (pos != std::string::npos) {
454        bundleName = bundleName.substr(0, pos);
455    }
456    std::string appName = bundleName.substr(0, strlen(bundleName.c_str()));
457    sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
458    if (sam == nullptr) {
459        DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d GetSystemAbilityManager", pid);
460        return false;
461    }
462    sptr<IRemoteObject> remoteObject = sam->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
463    if (remoteObject == nullptr) {
464        DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d Get BundleMgr SA failed!", pid);
465        return false;
466    }
467#ifdef HIDUMPER_BUNDLEMANAGER_FRAMEWORK_ENABLE
468    sptr<AppExecFwk::BundleMgrProxy> proxy = iface_cast<AppExecFwk::BundleMgrProxy>(remoteObject);
469    AppExecFwk::ApplicationInfo appInfo;
470    bool ret = proxy->GetApplicationInfo(appName, AppExecFwk::GET_APPLICATION_INFO_WITH_DISABLE,
471                                         AppExecFwk::Constants::ANY_USERID, appInfo);
472    if (!ret) {
473        DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d %{public}s Get App info failed!", pid, appName.c_str());
474        return false;
475    }
476    bool isDebugApp = (appInfo.appProvisionType == AppExecFwk::Constants::APP_PROVISION_TYPE_DEBUG);
477    DUMPER_HILOGD(MODULE_COMMON, "debug|pid %{public}d %{public}s DebugVersion %{public}d",
478        pid, appName.c_str(), isDebugApp);
479    return isDebugApp;
480#else
481    DUMPER_HILOGD(MODULE_COMMON, "debug|pid %{public}d %{public}s DebugVersion false", pid, appName.c_str());
482    return false;
483#endif
484}
485
486bool DumpUtils::IsHmKernel()
487{
488    bool isHM = false;
489    utsname unameBuf;
490    if ((uname(&unameBuf)) == 0) {
491        std::string osRelease = unameBuf.release;
492        isHM = osRelease.find("HongMeng") != std::string::npos;
493    }
494    return isHM;
495}
496} // namespace HiviewDFX
497} // namespace OHOS
498