qtaguid.c revision fe71a61e5b0cb666675900d206251a7c18ed944b 
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
31static const char* CTRL_PROCPATH = "/proc/net/xt_qtaguid/ctrl";
32static const int CTRL_MAX_INPUT_LEN = 128;
33static const char *GLOBAL_PACIFIER_PARAM = "/sys/module/xt_qtaguid/parameters/passive";
34static 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 */
44static int resTrackFd = -1;
45pthread_once_t resTrackInitDone = PTHREAD_ONCE_INIT;
46
47/* Only call once per process. */
48void 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 */
60static 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
83static 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
99int qtaguid_tagSocket(int sockfd, int tag, uid_t uid) {
100    char lineBuf[CTRL_MAX_INPUT_LEN];
101    int res;
102    /* Doing java-land a favor, enforcing "long" */
103    uint64_t kTag = ((uint64_t)tag << 32) & ~(1LLU<<63);
104
105
106    pthread_once(&resTrackInitDone, qtaguid_resTrack);
107
108    snprintf(lineBuf, sizeof(lineBuf), "t %d %llu %d", sockfd, kTag, uid);
109
110    ALOGV("Tagging socket %d with tag %llx{%u,0} for uid %d", sockfd, kTag, tag, uid);
111
112    res = write_ctrl(lineBuf);
113    if (res < 0) {
114        ALOGI("Tagging socket %d with tag %llx(%d) for uid %d failed errno=%d",
115             sockfd, kTag, tag, uid, res);
116    }
117
118    return res;
119}
120
121int qtaguid_untagSocket(int sockfd) {
122    char lineBuf[CTRL_MAX_INPUT_LEN];
123    int res;
124
125    ALOGV("Untagging socket %d", sockfd);
126
127    snprintf(lineBuf, sizeof(lineBuf), "u %d", sockfd);
128    res = write_ctrl(lineBuf);
129    if (res < 0) {
130        ALOGI("Untagging socket %d failed errno=%d", sockfd, res);
131    }
132
133    return res;
134}
135
136int qtaguid_setCounterSet(int counterSetNum, uid_t uid) {
137    char lineBuf[CTRL_MAX_INPUT_LEN];
138    int res;
139
140    ALOGV("Setting counters to set %d for uid %d", counterSetNum, uid);
141
142    snprintf(lineBuf, sizeof(lineBuf), "s %d %d", counterSetNum, uid);
143    res = write_ctrl(lineBuf);
144    return res;
145}
146
147int qtaguid_deleteTagData(int tag, uid_t uid) {
148    char lineBuf[CTRL_MAX_INPUT_LEN];
149    int fd, cnt = 0, res = 0;
150    uint64_t kTag = (uint64_t)tag << 32;
151
152    ALOGV("Deleting tag data with tag %llx{%d,0} for uid %d", kTag, tag, uid);
153
154    pthread_once(&resTrackInitDone, qtaguid_resTrack);
155
156    snprintf(lineBuf, sizeof(lineBuf), "d %llu %d", kTag, uid);
157    res = write_ctrl(lineBuf);
158    if (res < 0) {
159        ALOGI("Deleteing tag data with tag %llx/%d for uid %d failed with cnt=%d errno=%d",
160             kTag, tag, uid, cnt, errno);
161    }
162
163    return res;
164}
165
166int qtaguid_setPacifier(int on) {
167    int param_fd;
168    int res;
169    const char *value;
170
171    value = on ? "Y" : "N";
172    if (write_param(GLOBAL_PACIFIER_PARAM, value) < 0) {
173        return -errno;
174    }
175    if (write_param(TAG_PACIFIER_PARAM, value) < 0) {
176        return -errno;
177    }
178    return 0;
179}
180