1 /* libcutils/qtaguid.c
2 **
3 ** Copyright 2011, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 // #define LOG_NDEBUG 0
19
20 #define LOG_TAG "qtaguid"
21
22 #include <cutils/qtaguid.h>
23 #include <cutils/log.h>
24 #include <errno.h>
25 #include <fcntl.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <pthread.h>
30
31 static const char* CTRL_PROCPATH = "/proc/net/xt_qtaguid/ctrl";
32 static const int CTRL_MAX_INPUT_LEN = 128;
33 static const char *GLOBAL_PACIFIER_PARAM = "/sys/module/xt_qtaguid/parameters/passive";
34 static const char *TAG_PACIFIER_PARAM = "/sys/module/xt_qtaguid/parameters/tag_tracking_passive";
35
36 /*
37 * One per proccess.
38 * Once the device is open, this process will have its socket tags tracked.
39 * And on exit or untimely death, all socket tags will be removed.
40 * A process can only open /dev/xt_qtaguid once.
41 * It should not close it unless it is really done with all the socket tags.
42 * Failure to open it will be visible when socket tagging will be attempted.
43 */
44 static int resTrackFd = -1;
45 pthread_once_t resTrackInitDone = PTHREAD_ONCE_INIT;
46
47 /* Only call once per process. */
qtaguid_resTrack(void)48 void qtaguid_resTrack(void) {
49 resTrackFd = TEMP_FAILURE_RETRY(open("/dev/xt_qtaguid", O_RDONLY));
50 if (resTrackFd >=0) {
51 TEMP_FAILURE_RETRY(fcntl(resTrackFd, F_SETFD, FD_CLOEXEC));
52 }
53 }
54
55 /*
56 * Returns:
57 * 0 on success.
58 * -errno on failure.
59 */
write_ctrl(const char * cmd)60 static int write_ctrl(const char *cmd) {
61 int fd, res, savedErrno;
62
63 ALOGV("write_ctrl(%s)", cmd);
64
65 fd = TEMP_FAILURE_RETRY(open(CTRL_PROCPATH, O_WRONLY));
66 if (fd < 0) {
67 return -errno;
68 }
69
70 res = TEMP_FAILURE_RETRY(write(fd, cmd, strlen(cmd)));
71 if (res < 0) {
72 savedErrno = errno;
73 } else {
74 savedErrno = 0;
75 }
76 if (res < 0) {
77 ALOGI("Failed write_ctrl(%s) res=%d errno=%d", cmd, res, savedErrno);
78 }
79 close(fd);
80 return -savedErrno;
81 }
82
write_param(const char * param_path,const char * value)83 static int write_param(const char *param_path, const char *value) {
84 int param_fd;
85 int res;
86
87 param_fd = TEMP_FAILURE_RETRY(open(param_path, O_WRONLY));
88 if (param_fd < 0) {
89 return -errno;
90 }
91 res = TEMP_FAILURE_RETRY(write(param_fd, value, strlen(value)));
92 if (res < 0) {
93 return -errno;
94 }
95 close(param_fd);
96 return 0;
97 }
98
qtaguid_tagSocket(int sockfd,int tag,uid_t uid)99 int qtaguid_tagSocket(int sockfd, int tag, uid_t uid) {
100 char lineBuf[CTRL_MAX_INPUT_LEN];
101 int res;
102 uint64_t kTag = ((uint64_t)tag << 32);
103
104 pthread_once(&resTrackInitDone, qtaguid_resTrack);
105
106 snprintf(lineBuf, sizeof(lineBuf), "t %d %llu %d", sockfd, kTag, uid);
107
108 ALOGV("Tagging socket %d with tag %llx{%u,0} for uid %d", sockfd, kTag, tag, uid);
109
110 res = write_ctrl(lineBuf);
111 if (res < 0) {
112 ALOGI("Tagging socket %d with tag %llx(%d) for uid %d failed errno=%d",
113 sockfd, kTag, tag, uid, res);
114 }
115
116 return res;
117 }
118
qtaguid_untagSocket(int sockfd)119 int qtaguid_untagSocket(int sockfd) {
120 char lineBuf[CTRL_MAX_INPUT_LEN];
121 int res;
122
123 ALOGV("Untagging socket %d", sockfd);
124
125 snprintf(lineBuf, sizeof(lineBuf), "u %d", sockfd);
126 res = write_ctrl(lineBuf);
127 if (res < 0) {
128 ALOGI("Untagging socket %d failed errno=%d", sockfd, res);
129 }
130
131 return res;
132 }
133
qtaguid_setCounterSet(int counterSetNum,uid_t uid)134 int qtaguid_setCounterSet(int counterSetNum, uid_t uid) {
135 char lineBuf[CTRL_MAX_INPUT_LEN];
136 int res;
137
138 ALOGV("Setting counters to set %d for uid %d", counterSetNum, uid);
139
140 snprintf(lineBuf, sizeof(lineBuf), "s %d %d", counterSetNum, uid);
141 res = write_ctrl(lineBuf);
142 return res;
143 }
144
qtaguid_deleteTagData(int tag,uid_t uid)145 int qtaguid_deleteTagData(int tag, uid_t uid) {
146 char lineBuf[CTRL_MAX_INPUT_LEN];
147 int fd, cnt = 0, res = 0;
148 uint64_t kTag = (uint64_t)tag << 32;
149
150 ALOGV("Deleting tag data with tag %llx{%d,0} for uid %d", kTag, tag, uid);
151
152 pthread_once(&resTrackInitDone, qtaguid_resTrack);
153
154 snprintf(lineBuf, sizeof(lineBuf), "d %llu %d", kTag, uid);
155 res = write_ctrl(lineBuf);
156 if (res < 0) {
157 ALOGI("Deleteing tag data with tag %llx/%d for uid %d failed with cnt=%d errno=%d",
158 kTag, tag, uid, cnt, errno);
159 }
160
161 return res;
162 }
163
qtaguid_setPacifier(int on)164 int qtaguid_setPacifier(int on) {
165 int param_fd;
166 int res;
167 const char *value;
168
169 value = on ? "Y" : "N";
170 if (write_param(GLOBAL_PACIFIER_PARAM, value) < 0) {
171 return -errno;
172 }
173 if (write_param(TAG_PACIFIER_PARAM, value) < 0) {
174 return -errno;
175 }
176 return 0;
177 }
178