1 /*
2 * Copyright (c) 2020-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 "init_cmds.h"
16
17 #include <ctype.h>
18 #include <errno.h>
19 #include <fcntl.h>
20 #include <net/if.h>
21 #include <stdbool.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <sys/ioctl.h>
25 #include <sys/mount.h>
26 #include <sys/resource.h>
27 #include <sys/stat.h>
28 #include <sys/syscall.h>
29 #include <sys/sysmacros.h>
30 #include <sys/wait.h>
31 #include <unistd.h>
32
33 #include "init.h"
34 #include "init_jobs_internal.h"
35 #include "init_log.h"
36 #include "init_cmdexecutor.h"
37 #include "init_service_manager.h"
38 #include "init_utils.h"
39 #include "securec.h"
40
41 #ifndef OHOS_LITE
42 #include "hookmgr.h"
43 #include "bootstage.h"
44
45 /**
46 * init cmd hooking execute
47 */
InitCmdHookExecute(const char * cmdName,const char * cmdContent,INIT_TIMING_STAT * cmdTimer)48 static void InitCmdHookExecute(const char *cmdName, const char *cmdContent, INIT_TIMING_STAT *cmdTimer)
49 {
50 INIT_CMD_INFO context;
51
52 context.cmdName = cmdName;
53 context.cmdContent = cmdContent;
54 context.reserved = (const char *)cmdTimer;
55
56 (void)HookMgrExecute(GetBootStageHookMgr(), INIT_CMD_RECORD, (void *)(&context), NULL);
57 }
58 #endif
59
AddOneArg(const char * param,size_t paramLen)60 static char *AddOneArg(const char *param, size_t paramLen)
61 {
62 int valueCount = 1;
63 char *begin = strchr(param, '$');
64 while (begin != NULL) {
65 valueCount++;
66 begin = strchr(begin + 1, '$');
67 }
68 size_t allocSize = paramLen + (PARAM_VALUE_LEN_MAX * valueCount) + 1;
69 char *arg = calloc(allocSize, sizeof(char));
70 INIT_CHECK(arg != NULL, return NULL);
71 int ret = GetParamValue(param, paramLen, arg, allocSize);
72 INIT_ERROR_CHECK(ret == 0, free(arg);
73 return NULL, "Failed to get value for %s", param);
74 return arg;
75 }
76
BuildStringFromCmdArg(const struct CmdArgs * ctx,int startIndex)77 char *BuildStringFromCmdArg(const struct CmdArgs *ctx, int startIndex)
78 {
79 INIT_ERROR_CHECK(ctx != NULL, return NULL, "Failed to get cmd args ");
80 char *options = (char *)calloc(1, OPTIONS_SIZE + 1);
81 INIT_ERROR_CHECK(options != NULL, return NULL, "Failed to get memory ");
82 options[0] = '\0';
83 int curr = 0;
84 for (int i = startIndex; i < ctx->argc; i++) { // save opt
85 if (ctx->argv[i] == NULL) {
86 continue;
87 }
88 int len = snprintf_s(options + curr, OPTIONS_SIZE - curr, OPTIONS_SIZE - 1 - curr, "%s ", ctx->argv[i]);
89 if (len <= 0) {
90 INIT_LOGE("Failed to format other opt");
91 options[0] = '\0';
92 return options;
93 }
94 curr += len;
95 }
96 if ((curr > 0) && (curr < OPTIONS_SIZE)) {
97 options[curr - 1] = '\0';
98 }
99 return options;
100 }
101
GetCmdArg(const char * cmdContent,const char * delim,int argsCount)102 const struct CmdArgs *GetCmdArg(const char *cmdContent, const char *delim, int argsCount)
103 {
104 INIT_CHECK_RETURN_VALUE(cmdContent != NULL, NULL);
105 INIT_CHECK_RETURN_VALUE(delim != NULL, NULL);
106 INIT_WARNING_CHECK(argsCount <= SPACES_CNT_IN_CMD_MAX, argsCount = SPACES_CNT_IN_CMD_MAX,
107 "Too much arguments for command, max number is %d", SPACES_CNT_IN_CMD_MAX);
108 struct CmdArgs *ctx = (struct CmdArgs *)calloc(1, sizeof(struct CmdArgs) + sizeof(char *) * (argsCount + 1));
109 INIT_ERROR_CHECK(ctx != NULL, return NULL, "Failed to malloc memory for arg");
110 ctx->argc = 0;
111 const char *p = cmdContent;
112 const char *end = cmdContent + strlen(cmdContent);
113 const char *token = NULL;
114 do {
115 // Skip lead whitespaces
116 while (isspace(*p)) {
117 p++;
118 }
119 if (end == p) { // empty cmd content
120 break;
121 }
122 token = strstr(p, delim);
123 if (token == NULL) {
124 ctx->argv[ctx->argc] = AddOneArg(p, end - p);
125 INIT_CHECK(ctx->argv[ctx->argc] != NULL, FreeCmdArg(ctx);
126 return NULL);
127 } else {
128 ctx->argv[ctx->argc] = AddOneArg(p, token - p);
129 INIT_CHECK(ctx->argv[ctx->argc] != NULL, FreeCmdArg(ctx);
130 return NULL);
131 }
132 ctx->argc++;
133 ctx->argv[ctx->argc] = NULL;
134 if (ctx->argc == argsCount) {
135 break;
136 }
137 p = token;
138 } while (token != NULL);
139 return ctx;
140 }
141
FreeCmdArg(struct CmdArgs * cmd)142 void FreeCmdArg(struct CmdArgs *cmd)
143 {
144 INIT_CHECK_ONLY_RETURN(cmd != NULL);
145 for (int i = 0; i < cmd->argc; ++i) {
146 if (cmd->argv[i] != NULL) {
147 free(cmd->argv[i]);
148 }
149 }
150 free(cmd);
151 return;
152 }
153
ExecCmd(const struct CmdTable * cmd,const char * cmdContent)154 void ExecCmd(const struct CmdTable *cmd, const char *cmdContent)
155 {
156 INIT_ERROR_CHECK(cmd != NULL, return, "Invalid cmd.");
157 const struct CmdArgs *ctx = GetCmdArg(cmdContent, " ", cmd->maxArg);
158 if (ctx == NULL) {
159 INIT_LOGE("Invalid arguments cmd: %s content: %s", cmd->name, cmdContent);
160 } else if ((ctx->argc <= cmd->maxArg) && (ctx->argc >= cmd->minArg)) {
161 cmd->DoFuncion(ctx);
162 } else {
163 INIT_LOGE("Invalid arguments cmd: %s content: %s argc: %d %d", cmd->name, cmdContent, ctx->argc, cmd->maxArg);
164 }
165 FreeCmdArg((struct CmdArgs *)ctx);
166 }
167
SetProcName(const struct CmdArgs * ctx,const char * procFile)168 static void SetProcName(const struct CmdArgs *ctx, const char *procFile)
169 {
170 int fd = open(procFile, O_WRONLY | O_CREAT | O_CLOEXEC | O_TRUNC, S_IRUSR | S_IWUSR);
171 INIT_ERROR_CHECK(fd >= 0, return, "Failed to set %s errno: %d", procFile, errno);
172
173 size_t size = strlen(ctx->argv[0]);
174 ssize_t n = write(fd, ctx->argv[0], size);
175 INIT_ERROR_CHECK(n == (ssize_t)size, close(fd);
176 return, "Failed to write domainname errno: %d", errno);
177 close(fd);
178 }
179
DoSetDomainname(const struct CmdArgs * ctx)180 static void DoSetDomainname(const struct CmdArgs *ctx)
181 {
182 SetProcName(ctx, "/proc/sys/kernel/domainname");
183 }
184
DoSetHostname(const struct CmdArgs * ctx)185 static void DoSetHostname(const struct CmdArgs *ctx)
186 {
187 SetProcName(ctx, "/proc/sys/kernel/hostname");
188 }
189
DoSleep(const struct CmdArgs * ctx)190 static void DoSleep(const struct CmdArgs *ctx)
191 {
192 errno = 0;
193 unsigned long sleepTime = strtoul(ctx->argv[0], NULL, DECIMAL_BASE);
194 INIT_ERROR_CHECK(errno == 0, return, "cannot convert sleep time in command \" sleep \"");
195
196 // Limit sleep time in 5 seconds
197 const unsigned long sleepTimeLimit = 5;
198 INIT_CHECK(sleepTime <= sleepTimeLimit, sleepTime = sleepTimeLimit);
199 INIT_LOGI("Sleeping %d second(s)", sleepTime);
200 sleep((unsigned int)sleepTime);
201 }
202
DoWait(const struct CmdArgs * ctx)203 static void DoWait(const struct CmdArgs *ctx)
204 {
205 const int filePos = 0;
206 const int timePos = 1;
207 unsigned long waitSecond = WAIT_MAX_SECOND;
208
209 if (ctx->argc == timePos + 1) {
210 errno = 0;
211 waitSecond = strtoul(ctx->argv[timePos], NULL, DECIMAL_BASE);
212 INIT_ERROR_CHECK(errno == 0,
213 return, "cannot convert sleep time in command \" wait \"");
214 }
215
216 INIT_LOGI("Waiting %s %lu second(s)", ctx->argv[filePos], waitSecond);
217 WaitForFile(ctx->argv[filePos], waitSecond);
218 }
219
DoStart(const struct CmdArgs * ctx)220 static void DoStart(const struct CmdArgs *ctx)
221 {
222 INIT_LOGV("DoStart %s", ctx->argv[0]);
223 StartServiceByName(ctx->argv[0]);
224 }
225
DoStop(const struct CmdArgs * ctx)226 static void DoStop(const struct CmdArgs *ctx)
227 {
228 INIT_LOGV("DoStop %s", ctx->argv[0]);
229 StopServiceByName(ctx->argv[0]);
230 return;
231 }
232
DoReset(const struct CmdArgs * ctx)233 static void DoReset(const struct CmdArgs *ctx)
234 {
235 INIT_LOGV("DoReset %s", ctx->argv[0]);
236 Service *service = GetServiceByName(ctx->argv[0]);
237 if (service == NULL) {
238 INIT_LOGE("Reset cmd cannot find service %s.", ctx->argv[0]);
239 return;
240 }
241 if (service->pid > 0) {
242 if (kill(service->pid, GetKillServiceSig(ctx->argv[0])) != 0) {
243 INIT_LOGE("stop service %s pid %d failed! err %d.", service->name, service->pid, errno);
244 return;
245 }
246 } else {
247 StartServiceByName(ctx->argv[0]);
248 }
249 return;
250 }
251
DoCopy(const struct CmdArgs * ctx)252 static void DoCopy(const struct CmdArgs *ctx)
253 {
254 int srcFd = -1;
255 int dstFd = -1;
256 char buf[MAX_COPY_BUF_SIZE] = { 0 };
257 char *realPath1 = NULL;
258 char *realPath2 = NULL;
259 do {
260 realPath1 = GetRealPath(ctx->argv[0]);
261 if (realPath1 == NULL) {
262 INIT_LOGE("Failed to get real path %s", ctx->argv[0]);
263 break;
264 }
265
266 srcFd = open(realPath1, O_RDONLY);
267 if (srcFd < 0) {
268 INIT_LOGE("Failed to open source path %s %d", ctx->argv[0], errno);
269 break;
270 }
271
272 struct stat fileStat = { 0 };
273 if (stat(ctx->argv[0], &fileStat) != 0) {
274 INIT_LOGE("Failed to state source path %s %d", ctx->argv[0], errno);
275 break;
276 }
277 mode_t mode = fileStat.st_mode;
278 realPath2 = GetRealPath(ctx->argv[1]);
279 if (realPath2 != NULL) {
280 dstFd = open(realPath2, O_WRONLY | O_TRUNC | O_CREAT, mode);
281 } else {
282 dstFd = open(ctx->argv[1], O_WRONLY | O_TRUNC | O_CREAT, mode);
283 }
284 if (dstFd < 0) {
285 INIT_LOGE("Failed to open dest path %s %d", ctx->argv[1], errno);
286 break;
287 }
288 int rdLen = 0;
289 while ((rdLen = read(srcFd, buf, sizeof(buf) - 1)) > 0) {
290 int rtLen = write(dstFd, buf, rdLen);
291 if (rtLen != rdLen) {
292 INIT_LOGE("Failed to write to dest path %s %d", ctx->argv[1], errno);
293 break;
294 }
295 }
296 fsync(dstFd);
297 } while (0);
298 INIT_CHECK(srcFd < 0, close(srcFd));
299 INIT_CHECK(dstFd < 0, close(dstFd));
300 INIT_CHECK(realPath1 == NULL, free(realPath1));
301 INIT_CHECK(realPath2 == NULL, free(realPath2));
302 }
303
SetOwner(const char * file,const char * ownerStr,const char * groupStr)304 static int SetOwner(const char *file, const char *ownerStr, const char *groupStr)
305 {
306 INIT_ERROR_CHECK(file != NULL, return -1, "SetOwner invalid file.");
307 INIT_ERROR_CHECK(ownerStr != NULL, return -1, "SetOwner invalid file.");
308 INIT_ERROR_CHECK(groupStr != NULL, return -1, "SetOwner invalid file.");
309
310 uid_t owner = DecodeUid(ownerStr);
311 INIT_ERROR_CHECK(owner != (uid_t)-1, return -1, "SetOwner invalid uid : %s.", ownerStr);
312 gid_t group = DecodeGid(groupStr);
313 INIT_ERROR_CHECK(group != (gid_t)-1, return -1, "SetOwner invalid gid : %s.", groupStr);
314 return (chown(file, owner, group) != 0) ? -1 : 0;
315 }
316
DoChown(const struct CmdArgs * ctx)317 static void DoChown(const struct CmdArgs *ctx)
318 {
319 // format: chown owner group /xxx/xxx/xxx
320 const int pathPos = 2;
321 int ret = SetOwner(ctx->argv[pathPos], ctx->argv[0], ctx->argv[1]);
322 if (ret != 0) {
323 INIT_LOGE("Failed to change owner for %s, err %d.", ctx->argv[pathPos], errno);
324 }
325 return;
326 }
327
DoMkDir(const struct CmdArgs * ctx)328 static void DoMkDir(const struct CmdArgs *ctx)
329 {
330 // mkdir support format:
331 // 1.mkdir path
332 // 2.mkdir path mode
333 // 3.mkdir path mode owner group
334 const int ownerPos = 2;
335 const int groupPos = 3;
336 if (ctx->argc != 1 && ctx->argc != (groupPos + 1) && ctx->argc != ownerPos) {
337 INIT_LOGE("DoMkDir invalid arguments.");
338 return;
339 }
340 mode_t mode = DEFAULT_DIR_MODE;
341 if (mkdir(ctx->argv[0], mode) != 0 && errno != EEXIST) {
342 INIT_LOGE("Create directory '%s' failed, err=%d.", ctx->argv[0], errno);
343 return;
344 }
345
346 PluginExecCmdByName("restoreContentRecurse", ctx->argv[0]);
347
348 if (ctx->argc <= 1) {
349 return;
350 }
351
352 mode = strtoul(ctx->argv[1], NULL, OCTAL_TYPE);
353 INIT_CHECK_ONLY_ELOG(chmod(ctx->argv[0], mode) == 0, "DoMkDir failed for '%s', err %d.", ctx->argv[0], errno);
354
355 if (ctx->argc <= ownerPos) {
356 return;
357 }
358 int ret = SetOwner(ctx->argv[0], ctx->argv[ownerPos], ctx->argv[groupPos]);
359 if (ret != 0) {
360 INIT_LOGE("Failed to change owner %s, err %d.", ctx->argv[0], errno);
361 }
362 ret = SetFileCryptPolicy(ctx->argv[0]);
363 INIT_CHECK_ONLY_ELOG(ret == 0, "Failed to set file fscrypt");
364 return;
365 }
366
DoChmod(const struct CmdArgs * ctx)367 static void DoChmod(const struct CmdArgs *ctx)
368 {
369 // format: chmod xxxx /xxx/xxx/xxx
370 mode_t mode = strtoul(ctx->argv[0], NULL, OCTAL_TYPE);
371 if (mode == 0) {
372 INIT_LOGE("DoChmod, strtoul failed for %s, er %d.", ctx->argv[1], errno);
373 return;
374 }
375
376 if (chmod(ctx->argv[1], mode) != 0) {
377 INIT_LOGE("Failed to change mode \" %s \" to %04o, err=%d", ctx->argv[1], mode, errno);
378 }
379 }
380
GetMountFlag(unsigned long * mountflag,const char * targetStr,const char * source)381 static int GetMountFlag(unsigned long *mountflag, const char *targetStr, const char *source)
382 {
383 INIT_CHECK_RETURN_VALUE(targetStr != NULL && mountflag != NULL, 0);
384 struct {
385 char *flagName;
386 unsigned long value;
387 } mountFlagMap[] = {
388 { "noatime", MS_NOATIME },
389 { "noexec", MS_NOEXEC },
390 { "nosuid", MS_NOSUID },
391 { "nodev", MS_NODEV },
392 { "nodiratime", MS_NODIRATIME },
393 { "ro", MS_RDONLY },
394 { "rdonly", MS_RDONLY },
395 { "rw", 0 },
396 { "sync", MS_SYNCHRONOUS },
397 { "remount", MS_REMOUNT },
398 { "bind", MS_BIND },
399 { "rec", MS_REC },
400 { "unbindable", MS_UNBINDABLE },
401 { "private", MS_PRIVATE },
402 { "slave", MS_SLAVE },
403 { "shared", MS_SHARED },
404 { "defaults", 0 },
405 };
406 for (unsigned int i = 0; i < ARRAY_LENGTH(mountFlagMap); i++) {
407 if (strncmp(targetStr, mountFlagMap[i].flagName, strlen(mountFlagMap[i].flagName)) == 0) {
408 *mountflag |= mountFlagMap[i].value;
409 return 1;
410 }
411 }
412 if (strncmp(targetStr, "wait", strlen("wait")) == 0) {
413 WaitForFile(source, WAIT_MAX_SECOND);
414 return 1;
415 }
416
417 return 0;
418 }
419
DoMount(const struct CmdArgs * ctx)420 static void DoMount(const struct CmdArgs *ctx)
421 {
422 INIT_ERROR_CHECK(ctx->argc <= SPACES_CNT_IN_CMD_MAX, return, "Invalid arg number");
423 // format: fileSystemType source target mountFlag1 mountFlag2... data
424 int index = 0;
425 char *fileSysType = (ctx->argc > index) ? ctx->argv[index] : NULL;
426 INIT_ERROR_CHECK(fileSysType != NULL, return, "Failed to get fileSysType.");
427 index++;
428
429 char *source = (ctx->argc > index) ? ctx->argv[index] : NULL;
430 INIT_ERROR_CHECK(source != NULL, return, "Failed to get source.");
431 index++;
432
433 // maybe only has "filesystype source target", 2 spaces
434 char *target = (ctx->argc > index) ? ctx->argv[index] : NULL;
435 INIT_ERROR_CHECK(target != NULL, return, "Failed to get target.");
436 ++index;
437
438 int ret = 0;
439 unsigned long mountflags = 0;
440 while (index < ctx->argc) {
441 ret = GetMountFlag(&mountflags, ctx->argv[index], source);
442 if (ret == 0) {
443 break;
444 }
445 index++;
446 }
447 if (index >= ctx->argc) {
448 ret = mount(source, target, fileSysType, mountflags, NULL);
449 } else {
450 char *data = BuildStringFromCmdArg(ctx, index);
451 INIT_ERROR_CHECK(data != NULL, return, "Failed to get data.");
452 ret = mount(source, target, fileSysType, mountflags, data);
453 free(data);
454 }
455 if (ret != 0) {
456 INIT_LOGE("Failed to mount for %s, err %d.", target, errno);
457 }
458 }
459
DoWriteWithMultiArgs(const struct CmdArgs * ctx,int fd)460 static int DoWriteWithMultiArgs(const struct CmdArgs *ctx, int fd)
461 {
462 char buf[MAX_CMD_CONTENT_LEN];
463
464 /* Write to proc files should be done at once */
465 buf[0] = '\0';
466 INIT_ERROR_CHECK(strcat_s(buf, sizeof(buf), ctx->argv[1]) == 0, return -1, "Failed to format buf");
467 int idx = 2;
468 while (idx < ctx->argc) {
469 INIT_ERROR_CHECK(strcat_s(buf, sizeof(buf), " ") == 0, return -1, "Failed to format buf");
470 INIT_ERROR_CHECK(strcat_s(buf, sizeof(buf), ctx->argv[idx]) == 0, return -1, "Failed to format buf");
471 idx++;
472 }
473 return write(fd, buf, strlen(buf));
474 }
475
DoWrite(const struct CmdArgs * ctx)476 static void DoWrite(const struct CmdArgs *ctx)
477 {
478 // format: write path content
479 char *realPath = GetRealPath(ctx->argv[0]);
480 int fd = -1;
481 if (realPath != NULL) {
482 fd = open(realPath, O_WRONLY | O_CREAT | O_NOFOLLOW | O_CLOEXEC, S_IRUSR | S_IWUSR);
483 free(realPath);
484 realPath = NULL;
485 } else {
486 fd = open(ctx->argv[0], O_WRONLY | O_CREAT | O_NOFOLLOW | O_CLOEXEC, S_IRUSR | S_IWUSR);
487 }
488 if (fd < 0) {
489 return;
490 }
491 ssize_t ret;
492 if (ctx->argc > 2) {
493 ret = DoWriteWithMultiArgs(ctx, fd);
494 } else {
495 ret = write(fd, ctx->argv[1], strlen(ctx->argv[1]));
496 }
497 INIT_CHECK_ONLY_ELOG(ret >= 0, "DoWrite: write to file %s failed: %d", ctx->argv[0], errno);
498 close(fd);
499 }
500
DoRmdir(const struct CmdArgs * ctx)501 static void DoRmdir(const struct CmdArgs *ctx)
502 {
503 // format: rmdir path
504 int ret = rmdir(ctx->argv[0]);
505 if (ret == -1) {
506 INIT_LOGE("DoRmdir: remove %s failed: %d.", ctx->argv[0], errno);
507 }
508 return;
509 }
510
DoRebootCmd(const struct CmdArgs * ctx)511 static void DoRebootCmd(const struct CmdArgs *ctx)
512 {
513 ExecReboot(ctx->argv[0]);
514 return;
515 }
516
DoSetrlimit(const struct CmdArgs * ctx)517 static void DoSetrlimit(const struct CmdArgs *ctx)
518 {
519 static const char *resource[] = {
520 "RLIMIT_CPU", "RLIMIT_FSIZE", "RLIMIT_DATA", "RLIMIT_STACK", "RLIMIT_CORE", "RLIMIT_RSS",
521 "RLIMIT_NPROC", "RLIMIT_NOFILE", "RLIMIT_MEMLOCK", "RLIMIT_AS", "RLIMIT_LOCKS", "RLIMIT_SIGPENDING",
522 "RLIMIT_MSGQUEUE", "RLIMIT_NICE", "RLIMIT_RTPRIO", "RLIMIT_RTTIME", "RLIM_NLIMITS"
523 };
524 // format: setrlimit resource curValue maxValue
525 const int rlimMaxPos = 2;
526 struct rlimit limit;
527 if (strcmp(ctx->argv[1], "unlimited") == 0) {
528 limit.rlim_cur = RLIM_INFINITY;
529 } else {
530 limit.rlim_cur = (rlim_t)atoi(ctx->argv[1]);
531 }
532 if (strcmp(ctx->argv[rlimMaxPos], "unlimited") == 0) {
533 limit.rlim_max = RLIM_INFINITY;
534 } else {
535 limit.rlim_max = (rlim_t)atoi(ctx->argv[rlimMaxPos]);
536 }
537 int rcs = -1;
538 for (unsigned int i = 0; i < ARRAY_LENGTH(resource); ++i) {
539 if (strcmp(ctx->argv[0], resource[i]) == 0) {
540 rcs = (int)i;
541 break;
542 }
543 }
544 if (rcs == -1) {
545 INIT_LOGE("DoSetrlimit failed, resources :%s not support.", ctx->argv[0]);
546 return;
547 }
548 INIT_CHECK_ONLY_ELOG(setrlimit(rcs, &limit) == 0, "Failed setrlimit err=%d", errno);
549 return;
550 }
551
DoRm(const struct CmdArgs * ctx)552 static void DoRm(const struct CmdArgs *ctx)
553 {
554 // format: rm /xxx/xxx/xxx
555 INIT_CHECK_ONLY_ELOG(unlink(ctx->argv[0]) != -1, "Failed unlink %s err=%d.", ctx->argv[0], errno);
556 return;
557 }
558
DoExport(const struct CmdArgs * ctx)559 static void DoExport(const struct CmdArgs *ctx)
560 {
561 // format: export xxx /xxx/xxx/xxx
562 INIT_CHECK_ONLY_ELOG(setenv(ctx->argv[0], ctx->argv[1], 1) == 0, "Failed setenv %s with %s err=%d.",
563 ctx->argv[0], ctx->argv[1], errno);
564 return;
565 }
566
567 static const struct CmdTable g_cmdTable[] = {
568 { "start ", 0, 1, 0, DoStart },
569 { "mkdir ", 1, 4, 1, DoMkDir },
570 { "chmod ", 2, 2, 1, DoChmod },
571 { "chown ", 3, 3, 1, DoChown },
572 { "mount ", 1, 10, 0, DoMount },
573 { "export ", 2, 2, 0, DoExport },
574 { "rm ", 1, 1, 1, DoRm },
575 { "rmdir ", 1, 1, 1, DoRmdir },
576 { "write ", 2, 10, 1, DoWrite },
577 { "stop ", 1, 1, 0, DoStop },
578 { "reset ", 1, 1, 0, DoReset },
579 { "copy ", 2, 2, 1, DoCopy },
580 { "reboot ", 0, 1, 0, DoRebootCmd },
581 { "setrlimit ", 3, 3, 0, DoSetrlimit },
582 { "sleep ", 1, 1, 0, DoSleep },
583 { "wait ", 1, 2, 1, DoWait },
584 { "hostname ", 1, 1, 1, DoSetHostname },
585 { "domainname ", 1, 1, 1, DoSetDomainname }
586 };
587
GetCommCmdTable(int * number)588 static const struct CmdTable *GetCommCmdTable(int *number)
589 {
590 *number = (int)ARRAY_LENGTH(g_cmdTable);
591 return g_cmdTable;
592 }
593
GetCmdStart(const char * cmdContent)594 static char *GetCmdStart(const char *cmdContent)
595 {
596 // Skip lead whitespaces
597 char *p = (char *)cmdContent;
598 while (p != NULL && isspace(*p)) {
599 p++;
600 }
601 if (p == NULL) {
602 return NULL;
603 }
604 if (*p == '#') { // start with #
605 return NULL;
606 }
607 return p;
608 }
609
GetCmdByName(const char * name)610 const struct CmdTable *GetCmdByName(const char *name)
611 {
612 INIT_CHECK_RETURN_VALUE(name != NULL, NULL);
613 char *startCmd = GetCmdStart(name);
614 INIT_CHECK_RETURN_VALUE(startCmd != NULL, NULL);
615 int cmdCnt = 0;
616 const struct CmdTable *commCmds = GetCommCmdTable(&cmdCnt);
617 for (int i = 0; i < cmdCnt; ++i) {
618 if (strncmp(startCmd, commCmds[i].name, strlen(commCmds[i].name)) == 0) {
619 return &commCmds[i];
620 }
621 }
622 int number = 0;
623 const struct CmdTable *cmds = GetCmdTable(&number);
624 for (int i = 0; i < number; ++i) {
625 if (strncmp(startCmd, cmds[i].name, strlen(cmds[i].name)) == 0) {
626 return &cmds[i];
627 }
628 }
629 return NULL;
630 }
631
GetMatchCmd(const char * cmdStr,int * index)632 const char *GetMatchCmd(const char *cmdStr, int *index)
633 {
634 INIT_CHECK_RETURN_VALUE(cmdStr != NULL && index != NULL, NULL);
635 char *startCmd = GetCmdStart(cmdStr);
636 INIT_CHECK_RETURN_VALUE(startCmd != NULL, NULL);
637
638 int cmdCnt = 0;
639 const struct CmdTable *commCmds = GetCommCmdTable(&cmdCnt);
640 for (int i = 0; i < cmdCnt; ++i) {
641 if (strncmp(startCmd, commCmds[i].name, strlen(commCmds[i].name)) == 0) {
642 *index = i;
643 return commCmds[i].name;
644 }
645 }
646 int number = 0;
647 const struct CmdTable *cmds = GetCmdTable(&number);
648 for (int i = 0; i < number; ++i) {
649 if (strncmp(startCmd, cmds[i].name, strlen(cmds[i].name)) == 0) {
650 *index = cmdCnt + i;
651 return cmds[i].name;
652 }
653 }
654 return PluginGetCmdIndex(startCmd, index);
655 }
656
GetCmdTableByIndex(int index)657 static const struct CmdTable *GetCmdTableByIndex(int index)
658 {
659 int cmdCnt = 0;
660 const struct CmdTable *commCmds = GetCommCmdTable(&cmdCnt);
661 const struct CmdTable *cmdTable = NULL;
662 if (index < cmdCnt) {
663 cmdTable = &commCmds[index];
664 } else {
665 int number = 0;
666 const struct CmdTable *cmds = GetCmdTable(&number);
667 if (index < (cmdCnt + number)) {
668 cmdTable = &cmds[index - cmdCnt];
669 }
670 }
671 return cmdTable;
672 }
673
GetCmdKey(int index)674 const char *GetCmdKey(int index)
675 {
676 const struct CmdTable *cmdTable = GetCmdTableByIndex(index);
677 if (cmdTable != NULL) {
678 return cmdTable->name;
679 }
680 return GetPluginCmdNameByIndex(index);
681 }
682
GetCmdLinesFromJson(const cJSON * root,CmdLines ** cmdLines)683 int GetCmdLinesFromJson(const cJSON *root, CmdLines **cmdLines)
684 {
685 INIT_CHECK(root != NULL, return -1);
686 INIT_CHECK(cmdLines != NULL, return -1);
687 *cmdLines = NULL;
688 if (!cJSON_IsArray(root)) {
689 return -1;
690 }
691 int cmdCnt = cJSON_GetArraySize(root);
692 INIT_CHECK_RETURN_VALUE(cmdCnt > 0, -1);
693
694 *cmdLines = (CmdLines *)calloc(1, sizeof(CmdLines) + sizeof(CmdLine) * cmdCnt);
695 INIT_CHECK_RETURN_VALUE(*cmdLines != NULL, -1);
696 (*cmdLines)->cmdNum = 0;
697 for (int i = 0; i < cmdCnt; ++i) {
698 cJSON *line = cJSON_GetArrayItem(root, i);
699 if (!cJSON_IsString(line)) {
700 continue;
701 }
702
703 char *tmp = cJSON_GetStringValue(line);
704 if (tmp == NULL) {
705 continue;
706 }
707
708 int index = 0;
709 const char *cmd = GetMatchCmd(tmp, &index);
710 if (cmd == NULL) {
711 INIT_LOGE("Cannot support command: %s", tmp);
712 continue;
713 }
714
715 int ret = strcpy_s((*cmdLines)->cmds[(*cmdLines)->cmdNum].cmdContent, MAX_CMD_CONTENT_LEN, tmp + strlen(cmd));
716 if (ret != EOK) {
717 INIT_LOGE("Invalid cmd arg: %s", tmp);
718 continue;
719 }
720
721 (*cmdLines)->cmds[(*cmdLines)->cmdNum].cmdIndex = index;
722 (*cmdLines)->cmdNum++;
723 }
724 return 0;
725 }
726
InitDiffTime(INIT_TIMING_STAT * stat)727 long long InitDiffTime(INIT_TIMING_STAT *stat)
728 {
729 long long diff = (long long)((stat->endTime.tv_sec - stat->startTime.tv_sec) * 1000000); // 1000000 1000ms
730 if (stat->endTime.tv_nsec > stat->startTime.tv_nsec) {
731 diff += (stat->endTime.tv_nsec - stat->startTime.tv_nsec) / BASE_MS_UNIT;
732 } else {
733 diff -= (stat->startTime.tv_nsec - stat->endTime.tv_nsec) / BASE_MS_UNIT;
734 }
735 return diff;
736 }
737
DoCmdByIndex(int index,const char * cmdContent,const ConfigContext * context)738 void DoCmdByIndex(int index, const char *cmdContent, const ConfigContext *context)
739 {
740 if (cmdContent == NULL) {
741 return;
742 }
743 INIT_TIMING_STAT cmdTimer;
744 (void)clock_gettime(CLOCK_MONOTONIC, &cmdTimer.startTime);
745
746 const char *cmdName = NULL;
747 const struct CmdTable *cmdTable = GetCmdTableByIndex(index);
748 if (cmdTable != NULL) {
749 cmdName = cmdTable->name;
750 if (!cmdTable->careContext || !CheckExecuteInSubInit(context)) {
751 ExecCmd(cmdTable, cmdContent);
752 } else {
753 ExecuteCmdInSubInit(context, cmdTable->name, cmdContent);
754 }
755 } else {
756 PluginExecCmdByCmdIndex(index, cmdContent, context);
757 cmdName = GetPluginCmdNameByIndex(index);
758 if (cmdName == NULL) {
759 cmdName = "Unknown";
760 }
761 }
762
763 (void)clock_gettime(CLOCK_MONOTONIC, &cmdTimer.endTime);
764 long long diff = InitDiffTime(&cmdTimer);
765 #ifndef OHOS_LITE
766 InitCmdHookExecute(cmdName, cmdContent, &cmdTimer);
767 #endif
768 if (diff > 200000) { // 200000 > 200ms
769 INIT_LOGI("Execute command \"%s %s\" took %lld ms", cmdName, cmdContent, diff / BASE_MS_UNIT);
770 } else {
771 INIT_LOGV("Execute command \"%s %s\" took %lld ms", cmdName, cmdContent, diff / BASE_MS_UNIT);
772 }
773 }
774