1 /*
2  * Copyright (C) 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #pragma once
17 
18 #ifndef INCIDENTD_UTIL_H
19 #define INCIDENTD_UTIL_H
20 
21 #include <stdarg.h>
22 #include <utils/Errors.h>
23 
24 #include "Privacy.h"
25 
26 namespace android {
27 
28 namespace util {
29 class EncodedBuffer;
30 }
31 
32 namespace os {
33 namespace incidentd {
34 
35 using android::base::unique_fd;
36 using android::util::EncodedBuffer;
37 
38 /**
39  * Looks up Privacy of a section in the auto-gen PRIVACY_POLICY_LIST;
40  */
41 const Privacy* get_privacy_of_section(int id);
42 
43 /**
44  * Get an EncodedBuffer from an internal pool, or create and return a new one if the pool is empty.
45  * The EncodedBuffer should be returned after use.
46  * Thread safe.
47  */
48 sp<EncodedBuffer> get_buffer_from_pool();
49 
50 /**
51  * Return the EncodedBuffer back to the pool for reuse.
52  * Thread safe.
53  */
54 void return_buffer_to_pool(sp<EncodedBuffer> buffer);
55 
56 /**
57  * Clear the buffer pool to free memory, after taking an incident report.
58  * Thread safe.
59  */
60 void clear_buffer_pool();
61 
62 /**
63  * This class wraps android::base::Pipe.
64  */
65 class Fpipe {
66 public:
67     Fpipe();
68     ~Fpipe();
69 
70     bool init();
71     bool close();
72     unique_fd& readFd();
73     unique_fd& writeFd();
74 
75 private:
76     unique_fd mRead;
77     unique_fd mWrite;
78 };
79 
80 /**
81  * Forks and exec a command with two pipes and returns the pid of the child, or -1 when it fails.
82  *
83  * input connects stdin for input. output connects stdout for output. input can be nullptr to
84  * indicate that child process doesn't read stdin. This function will close in and out fds upon
85  * success. If status is not NULL, the status information will be stored in the int to which it
86  * points.
87  */
88 pid_t fork_execute_cmd(char* const argv[], Fpipe* input, Fpipe* output, int* status = nullptr);
89 
90 /**
91  * Forks and exec a command that reads from in fd and writes to out fd and returns the pid of the
92  * child, or -1 when it fails.
93  *
94  * in can be -1 to indicate that child process doesn't read stdin. This function will close in and
95  * out fds upon success. If status is not NULL, the status information will be stored in the int
96  * to which it points.
97  */
98 pid_t fork_execute_cmd(char* const argv[], int in, int out, int* status = nullptr);
99 
100 /**
101  * Grabs varargs from stack and stores them in heap with NULL-terminated array.
102  */
103 const char** varargs(const char* first, va_list rest);
104 
105 /**
106  * Returns the current monotonic clock time in nanoseconds.
107  */
108 uint64_t Nanotime();
109 
110 /**
111  * Methods to wait or kill child process, return exit status code.
112  */
113 status_t kill_child(pid_t pid);
114 status_t wait_child(pid_t pid, int timeout_ms = 1000);
115 
116 status_t start_detached_thread(const function<void ()>& func);
117 
118 }  // namespace incidentd
119 }  // namespace os
120 }  // namespace android
121 
122 #endif  // INCIDENTD_UTIL_H
123