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 <log/log.h> 30#include <cutils/qtaguid.h> 31 32static const char* CTRL_PROCPATH = "/proc/net/xt_qtaguid/ctrl"; 33static const int CTRL_MAX_INPUT_LEN = 128; 34static const char *GLOBAL_PACIFIER_PARAM = "/sys/module/xt_qtaguid/parameters/passive"; 35static 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 */ 45static int resTrackFd = -1; 46pthread_once_t resTrackInitDone = PTHREAD_ONCE_INIT; 47 48/* Only call once per process. */ 49void qtaguid_resTrack(void) { 50 resTrackFd = TEMP_FAILURE_RETRY(open("/dev/xt_qtaguid", O_RDONLY | O_CLOEXEC)); 51} 52 53/* 54 * Returns: 55 * 0 on success. 56 * -errno on failure. 57 */ 58static int write_ctrl(const char *cmd) { 59 int fd, res, savedErrno; 60 61 ALOGV("write_ctrl(%s)", cmd); 62 63 fd = TEMP_FAILURE_RETRY(open(CTRL_PROCPATH, O_WRONLY | O_CLOEXEC)); 64 if (fd < 0) { 65 return -errno; 66 } 67 68 res = TEMP_FAILURE_RETRY(write(fd, cmd, strlen(cmd))); 69 if (res < 0) { 70 savedErrno = errno; 71 } else { 72 savedErrno = 0; 73 } 74 if (res < 0) { 75 // ALOGV is enough because all the callers also log failures 76 ALOGV("Failed write_ctrl(%s) res=%d errno=%d", cmd, res, savedErrno); 77 } 78 close(fd); 79 return -savedErrno; 80} 81 82static int write_param(const char *param_path, const char *value) { 83 int param_fd; 84 int res; 85 86 param_fd = TEMP_FAILURE_RETRY(open(param_path, O_WRONLY | O_CLOEXEC)); 87 if (param_fd < 0) { 88 return -errno; 89 } 90 res = TEMP_FAILURE_RETRY(write(param_fd, value, strlen(value))); 91 if (res < 0) { 92 return -errno; 93 } 94 close(param_fd); 95 return 0; 96} 97 98int qtaguid_tagSocket(int sockfd, int tag, uid_t uid) { 99 char lineBuf[CTRL_MAX_INPUT_LEN]; 100 int res; 101 uint64_t kTag = ((uint64_t)tag << 32); 102 103 pthread_once(&resTrackInitDone, qtaguid_resTrack); 104 105 snprintf(lineBuf, sizeof(lineBuf), "t %d %" PRIu64 " %d", sockfd, kTag, uid); 106 107 ALOGV("Tagging socket %d with tag %" PRIx64 "{%u,0} for uid %d", sockfd, kTag, tag, uid); 108 109 res = write_ctrl(lineBuf); 110 if (res < 0) { 111 ALOGI("Tagging socket %d with tag %" PRIx64 "(%d) for uid %d failed errno=%d", 112 sockfd, kTag, tag, uid, res); 113 } 114 115 return res; 116} 117 118int qtaguid_untagSocket(int sockfd) { 119 char lineBuf[CTRL_MAX_INPUT_LEN]; 120 int res; 121 122 ALOGV("Untagging socket %d", sockfd); 123 124 snprintf(lineBuf, sizeof(lineBuf), "u %d", sockfd); 125 res = write_ctrl(lineBuf); 126 if (res < 0) { 127 ALOGI("Untagging socket %d failed errno=%d", sockfd, res); 128 } 129 130 return res; 131} 132 133int qtaguid_setCounterSet(int counterSetNum, uid_t uid) { 134 char lineBuf[CTRL_MAX_INPUT_LEN]; 135 int res; 136 137 ALOGV("Setting counters to set %d for uid %d", counterSetNum, uid); 138 139 snprintf(lineBuf, sizeof(lineBuf), "s %d %d", counterSetNum, uid); 140 res = write_ctrl(lineBuf); 141 return res; 142} 143 144int qtaguid_deleteTagData(int tag, uid_t uid) { 145 char lineBuf[CTRL_MAX_INPUT_LEN]; 146 int cnt = 0, res = 0; 147 uint64_t kTag = (uint64_t)tag << 32; 148 149 ALOGV("Deleting tag data with tag %" PRIx64 "{%d,0} for uid %d", kTag, tag, uid); 150 151 pthread_once(&resTrackInitDone, qtaguid_resTrack); 152 153 snprintf(lineBuf, sizeof(lineBuf), "d %" PRIu64 " %d", kTag, uid); 154 res = write_ctrl(lineBuf); 155 if (res < 0) { 156 ALOGI("Deleting tag data with tag %" PRIx64 "/%d for uid %d failed with cnt=%d errno=%d", 157 kTag, tag, uid, cnt, errno); 158 } 159 160 return res; 161} 162 163int qtaguid_setPacifier(int on) { 164 const char *value; 165 166 value = on ? "Y" : "N"; 167 if (write_param(GLOBAL_PACIFIER_PARAM, value) < 0) { 168 return -errno; 169 } 170 if (write_param(TAG_PACIFIER_PARAM, value) < 0) { 171 return -errno; 172 } 173 return 0; 174} 175