1 /*
2 ** Copyright 2011, 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
17 // #define LOG_NDEBUG 0
18
19 #define LOG_TAG "qtaguid"
20
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <inttypes.h>
24 #include <pthread.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <unistd.h>
28
29 #include <cutils/qtaguid.h>
30 #include <log/log.h>
31
32 static const char* CTRL_PROCPATH = "/proc/net/xt_qtaguid/ctrl";
33 static const int CTRL_MAX_INPUT_LEN = 128;
34 static const char *GLOBAL_PACIFIER_PARAM = "/sys/module/xt_qtaguid/parameters/passive";
35 static const char *TAG_PACIFIER_PARAM = "/sys/module/xt_qtaguid/parameters/tag_tracking_passive";
36
37 /*
38 * One per proccess.
39 * Once the device is open, this process will have its socket tags tracked.
40 * And on exit or untimely death, all socket tags will be removed.
41 * A process can only open /dev/xt_qtaguid once.
42 * It should not close it unless it is really done with all the socket tags.
43 * Failure to open it will be visible when socket tagging will be attempted.
44 */
45 static int resTrackFd = -1;
46 pthread_once_t resTrackInitDone = PTHREAD_ONCE_INIT;
47
48 /* Only call once per process. */
qtaguid_resTrack(void)49 void qtaguid_resTrack(void) {
50 resTrackFd = TEMP_FAILURE_RETRY(open("/dev/xt_qtaguid", O_RDONLY));
51 if (resTrackFd >=0) {
52 TEMP_FAILURE_RETRY(fcntl(resTrackFd, F_SETFD, FD_CLOEXEC));
53 }
54 }
55
56 /*
57 * Returns:
58 * 0 on success.
59 * -errno on failure.
60 */
write_ctrl(const char * cmd)61 static int write_ctrl(const char *cmd) {
62 int fd, res, savedErrno;
63
64 ALOGV("write_ctrl(%s)", cmd);
65
66 fd = TEMP_FAILURE_RETRY(open(CTRL_PROCPATH, O_WRONLY));
67 if (fd < 0) {
68 return -errno;
69 }
70
71 res = TEMP_FAILURE_RETRY(write(fd, cmd, strlen(cmd)));
72 if (res < 0) {
73 savedErrno = errno;
74 } else {
75 savedErrno = 0;
76 }
77 if (res < 0) {
78 ALOGI("Failed write_ctrl(%s) res=%d errno=%d", cmd, res, savedErrno);
79 }
80 close(fd);
81 return -savedErrno;
82 }
83
write_param(const char * param_path,const char * value)84 static int write_param(const char *param_path, const char *value) {
85 int param_fd;
86 int res;
87
88 param_fd = TEMP_FAILURE_RETRY(open(param_path, O_WRONLY));
89 if (param_fd < 0) {
90 return -errno;
91 }
92 res = TEMP_FAILURE_RETRY(write(param_fd, value, strlen(value)));
93 if (res < 0) {
94 return -errno;
95 }
96 close(param_fd);
97 return 0;
98 }
99
qtaguid_tagSocket(int sockfd,int tag,uid_t uid)100 int qtaguid_tagSocket(int sockfd, int tag, uid_t uid) {
101 char lineBuf[CTRL_MAX_INPUT_LEN];
102 int res;
103 uint64_t kTag = ((uint64_t)tag << 32);
104
105 pthread_once(&resTrackInitDone, qtaguid_resTrack);
106
107 snprintf(lineBuf, sizeof(lineBuf), "t %d %" PRIu64 " %d", sockfd, kTag, uid);
108
109 ALOGV("Tagging socket %d with tag %" PRIx64 "{%u,0} for uid %d", sockfd, kTag, tag, uid);
110
111 res = write_ctrl(lineBuf);
112 if (res < 0) {
113 ALOGI("Tagging socket %d with tag %" PRIx64 "(%d) for uid %d failed errno=%d",
114 sockfd, kTag, tag, uid, res);
115 }
116
117 return res;
118 }
119
qtaguid_untagSocket(int sockfd)120 int qtaguid_untagSocket(int sockfd) {
121 char lineBuf[CTRL_MAX_INPUT_LEN];
122 int res;
123
124 ALOGV("Untagging socket %d", sockfd);
125
126 snprintf(lineBuf, sizeof(lineBuf), "u %d", sockfd);
127 res = write_ctrl(lineBuf);
128 if (res < 0) {
129 ALOGI("Untagging socket %d failed errno=%d", sockfd, res);
130 }
131
132 return res;
133 }
134
qtaguid_setCounterSet(int counterSetNum,uid_t uid)135 int qtaguid_setCounterSet(int counterSetNum, uid_t uid) {
136 char lineBuf[CTRL_MAX_INPUT_LEN];
137 int res;
138
139 ALOGV("Setting counters to set %d for uid %d", counterSetNum, uid);
140
141 snprintf(lineBuf, sizeof(lineBuf), "s %d %d", counterSetNum, uid);
142 res = write_ctrl(lineBuf);
143 return res;
144 }
145
qtaguid_deleteTagData(int tag,uid_t uid)146 int qtaguid_deleteTagData(int tag, uid_t uid) {
147 char lineBuf[CTRL_MAX_INPUT_LEN];
148 int cnt = 0, res = 0;
149 uint64_t kTag = (uint64_t)tag << 32;
150
151 ALOGV("Deleting tag data with tag %" PRIx64 "{%d,0} for uid %d", kTag, tag, uid);
152
153 pthread_once(&resTrackInitDone, qtaguid_resTrack);
154
155 snprintf(lineBuf, sizeof(lineBuf), "d %" PRIu64 " %d", kTag, uid);
156 res = write_ctrl(lineBuf);
157 if (res < 0) {
158 ALOGI("Deleting tag data with tag %" PRIx64 "/%d for uid %d failed with cnt=%d errno=%d",
159 kTag, tag, uid, cnt, errno);
160 }
161
162 return res;
163 }
164
qtaguid_setPacifier(int on)165 int qtaguid_setPacifier(int on) {
166 const char *value;
167
168 value = on ? "Y" : "N";
169 if (write_param(GLOBAL_PACIFIER_PARAM, value) < 0) {
170 return -errno;
171 }
172 if (write_param(TAG_PACIFIER_PARAM, value) < 0) {
173 return -errno;
174 }
175 return 0;
176 }
177