1 /*
2 * Copyright (c) 2021-2023 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 "faultloggerd_client.h"
16
17 #include <cstdint>
18 #include <cstdlib>
19 #include <functional>
20
21 #include <securec.h>
22 #include <sys/socket.h>
23 #include <sys/syscall.h>
24 #include <sys/un.h>
25 #include <sys/stat.h>
26
27 #include "dfx_cutil.h"
28 #include "dfx_define.h"
29 #include "dfx_log.h"
30 #include "dfx_socket_request.h"
31 #include "dfx_util.h"
32 #include "faultloggerd_socket.h"
33 #include "smart_fd.h"
34
35 namespace {
36 constexpr const char* const FAULTLOGGERD_CLIENT_TAG = "FAULT_LOGGERD_CLIENT";
37 constexpr int32_t SOCKET_TIMEOUT = 1;
GetSocketName()38 std::string GetSocketName()
39 {
40 char content[NAME_BUF_LEN];
41 GetProcessName(content, sizeof(content));
42 return strcmp(content, "processdump") == 0 ? SERVER_CRASH_SOCKET_NAME : SERVER_SOCKET_NAME;
43 }
44
FillRequestHeadData(RequestDataHead & head,FaultLoggerClientType clientType)45 void FillRequestHeadData(RequestDataHead& head, FaultLoggerClientType clientType)
46 {
47 head.clientType = clientType;
48 head.clientPid = getpid();
49 }
50
SendRequestToSocket(int32_t sockFd,const std::string & socketName,const void * data,size_t dataSize)51 int32_t SendRequestToSocket(int32_t sockFd, const std::string& socketName, const void* data, size_t dataSize)
52 {
53 if (!StartConnect(sockFd, socketName.c_str(), SOCKET_TIMEOUT)) {
54 return ResponseCode::CONNECT_FAILED;
55 }
56 if (!SendMsgToSocket(sockFd, data, dataSize)) {
57 return ResponseCode::SEND_DATA_FAILED;
58 }
59 int32_t retCode{ResponseCode::RECEIVE_DATA_FAILED};
60 GetMsgFromSocket(sockFd, &retCode, sizeof (retCode));
61 return retCode;
62 }
63
SendRequestToServer(const std::string & socketName,const void * data,size_t dataSize,const std::function<int32_t (int32_t,int32_t)> & resultHandler=nullptr)64 int32_t SendRequestToServer(const std::string& socketName, const void* data, size_t dataSize,
65 const std::function<int32_t(int32_t, int32_t)>& resultHandler = nullptr)
66 {
67 OHOS::HiviewDFX::SmartFd sockFd = CreateSocketFd();
68 int32_t retCode = SendRequestToSocket(sockFd, socketName, data, dataSize);
69 if (resultHandler) {
70 retCode = resultHandler(sockFd, retCode);
71 }
72 if (retCode != ResponseCode::REQUEST_SUCCESS) {
73 DFXLOGE("%{public}s.%{public}s :: request failed and retCode %{public}d", FAULTLOGGERD_CLIENT_TAG,
74 __func__, retCode);
75 }
76 return retCode;
77 }
78
RequestFileDescriptorFromServer(const std::string & socketName,const void * requestData,size_t requestSize,int * fds,uint32_t nFds)79 int32_t RequestFileDescriptorFromServer(const std::string& socketName, const void* requestData,
80 size_t requestSize, int* fds, uint32_t nFds)
81 {
82 return SendRequestToServer(socketName, requestData, requestSize, [fds, nFds] (int32_t socketFd, int32_t retCode) {
83 if (retCode != ResponseCode::REQUEST_SUCCESS) {
84 return retCode;
85 }
86 return ReadFileDescriptorFromSocket(socketFd, fds, nFds) ? retCode : ResponseCode::RECEIVE_DATA_FAILED;
87 });
88 }
89
RequestFileDescriptor(const struct FaultLoggerdRequest & request)90 int32_t RequestFileDescriptor(const struct FaultLoggerdRequest &request)
91 {
92 int32_t fd{-1};
93 switch (request.type) {
94 case CPP_CRASH:
95 case CPP_STACKTRACE:
96 case LEAK_STACKTRACE:
97 case JIT_CODE_LOG:
98 RequestFileDescriptorFromServer(SERVER_CRASH_SOCKET_NAME, &request, sizeof(request), &fd, 1);
99 return fd;
100 default:
101 RequestFileDescriptorFromServer(SERVER_SOCKET_NAME, &request, sizeof(request), &fd, 1);
102 return fd;
103 }
104 }
105 }
106
RequestFileDescriptor(int32_t type)107 int32_t RequestFileDescriptor(int32_t type)
108 {
109 struct FaultLoggerdRequest request{};
110 FillRequestHeadData(request.head, FaultLoggerClientType::LOG_FILE_DES_CLIENT);
111 request.type = type;
112 request.pid = request.head.clientPid;
113 request.tid = gettid();
114 request.time = OHOS::HiviewDFX::GetTimeMilliSeconds();
115 return RequestFileDescriptor(request);
116 }
117
RequestFileDescriptorEx(struct FaultLoggerdRequest * request)118 int32_t RequestFileDescriptorEx(struct FaultLoggerdRequest* request)
119 {
120 if (request == nullptr) {
121 DFXLOGE("%{public}s.%{public}s :: RequestFileDescriptorEx nullptr.", FAULTLOGGERD_CLIENT_TAG, __func__);
122 return -1;
123 }
124 FillRequestHeadData(request->head, FaultLoggerClientType::LOG_FILE_DES_CLIENT);
125 return RequestFileDescriptor(*request);
126 }
127
RequestSdkDump(int32_t pid,int32_t tid,int (& pipeReadFd)[2],bool isJson,int timeout)128 int32_t RequestSdkDump(int32_t pid, int32_t tid, int (&pipeReadFd)[2], bool isJson, int timeout)
129 {
130 #ifndef is_ohos_lite
131 DFXLOGI("%{public}s.%{public}s :: pid: %{public}d, tid: %{public}d, isJson: %{public}d.",
132 FAULTLOGGERD_CLIENT_TAG, __func__, pid, tid, isJson);
133 if (pid <= 0 || tid < 0) {
134 return ResponseCode::DEFAULT_ERROR_CODE;
135 }
136 struct SdkDumpRequestData request{};
137 FillRequestHeadData(request.head, FaultLoggerClientType::SDK_DUMP_CLIENT);
138 request.sigCode = isJson ? DUMP_TYPE_REMOTE_JSON : DUMP_TYPE_REMOTE;
139 request.pid = pid;
140 request.tid = tid;
141 request.callerTid = gettid();
142 request.time = OHOS::HiviewDFX::GetTimeMilliSeconds();
143 request.endTime = GetAbsTimeMilliSeconds() + static_cast<uint64_t>(timeout);
144 return RequestFileDescriptorFromServer(SERVER_SDKDUMP_SOCKET_NAME, &request,
145 sizeof(request), pipeReadFd, PIPE_NUM_SZ);
146 #else
147 return ResponseCode::DEFAULT_ERROR_CODE;
148 #endif
149 }
150
RequestPipeFd(int32_t pid,int32_t pipeType,int (& pipeFd)[2])151 int32_t RequestPipeFd(int32_t pid, int32_t pipeType, int (&pipeFd)[2])
152 {
153 #ifndef is_ohos_lite
154 if (pipeType < FaultLoggerPipeType::PIPE_FD_READ || pipeType > FaultLoggerPipeType::PIPE_FD_DELETE) {
155 DFXLOGE("%{public}s.%{public}s :: pipeType: %{public}d failed.", FAULTLOGGERD_CLIENT_TAG, __func__, pipeType);
156 return ResponseCode::DEFAULT_ERROR_CODE;
157 }
158 PipFdRequestData request{};
159 FillRequestHeadData(request.head, FaultLoggerClientType::PIPE_FD_CLIENT);
160 request.pipeType = static_cast<int8_t>(pipeType);
161 request.pid = pid;
162 return RequestFileDescriptorFromServer(GetSocketName(), &request, sizeof(request), pipeFd, PIPE_NUM_SZ);
163 #else
164 return ResponseCode::DEFAULT_ERROR_CODE;
165 #endif
166 }
167
RequestDelPipeFd(int32_t pid)168 int32_t RequestDelPipeFd(int32_t pid)
169 {
170 #ifndef is_ohos_lite
171 PipFdRequestData request{};
172 FillRequestHeadData(request.head, FaultLoggerClientType::PIPE_FD_CLIENT);
173 request.pipeType = FaultLoggerPipeType::PIPE_FD_DELETE;
174 request.pid = pid;
175 return SendRequestToServer(GetSocketName(), &request, sizeof(request));
176 #else
177 return ResponseCode::DEFAULT_ERROR_CODE;
178 #endif
179 }
180
ReportDumpStats(struct FaultLoggerdStatsRequest * request)181 int32_t ReportDumpStats(struct FaultLoggerdStatsRequest *request)
182 {
183 #ifndef HISYSEVENT_DISABLE
184 if (request == nullptr) {
185 return ResponseCode::DEFAULT_ERROR_CODE;
186 }
187 FillRequestHeadData(request->head, FaultLoggerClientType::DUMP_STATS_CLIENT);
188 OHOS::HiviewDFX::SmartFd socketFd = CreateSocketFd();
189 if (!StartConnect(socketFd, GetSocketName().c_str(), SOCKET_TIMEOUT)) {
190 DFXLOGE("%{public}s.%{public}s :: failed to connect server.", FAULTLOGGERD_CLIENT_TAG, __func__);
191 return ResponseCode::CONNECT_FAILED;
192 }
193 if (!SendMsgToSocket(socketFd, request, sizeof (FaultLoggerdStatsRequest))) {
194 DFXLOGE("%{public}s.%{public}s :: failed to send msg to server.", FAULTLOGGERD_CLIENT_TAG, __func__);
195 return ResponseCode::SEND_DATA_FAILED;
196 }
197 #endif
198 return ResponseCode::REQUEST_SUCCESS;
199 }