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. */ 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 */ 60 static int write_ctrl(const char *cmd) { 61 int fd, res, savedErrno; 62 63 LOGV("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 LOGI("Failed write_ctrl(%s) res=%d errno=%d", cmd, res, savedErrno); 78 } 79 close(fd); 80 return -savedErrno; 81 } 82 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 99 int 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 LOGV("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 LOGI("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 121 int qtaguid_untagSocket(int sockfd) { 122 char lineBuf[CTRL_MAX_INPUT_LEN]; 123 int res; 124 125 LOGV("Untagging socket %d", sockfd); 126 127 snprintf(lineBuf, sizeof(lineBuf), "u %d", sockfd); 128 res = write_ctrl(lineBuf); 129 if (res < 0) { 130 LOGI("Untagging socket %d failed errno=%d", sockfd, res); 131 } 132 133 return res; 134 } 135 136 int qtaguid_setCounterSet(int counterSetNum, uid_t uid) { 137 char lineBuf[CTRL_MAX_INPUT_LEN]; 138 int res; 139 140 LOGV("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 147 int 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 LOGV("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 LOGI("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 166 int 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