1 /* 2 * Copyright (C) 2010 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_TAG "TrafficStats" 18 19 #include <dirent.h> 20 #include <errno.h> 21 #include <fcntl.h> 22 #include <sys/stat.h> 23 #include <sys/types.h> 24 25 #include <android_runtime/AndroidRuntime.h> 26 #include <cutils/logger.h> 27 #include <jni.h> 28 #include <ScopedUtfChars.h> 29 #include <utils/misc.h> 30 #include <utils/Log.h> 31 32 namespace android { 33 34 static const uint64_t VALUE_UNKNOWN = -1; 35 static const char* IFACE_STAT_ALL = "/proc/net/xt_qtaguid/iface_stat_all"; 36 37 enum Tx_Rx { 38 TX, 39 RX 40 }; 41 42 enum Tcp_Udp { 43 TCP, 44 UDP, 45 TCP_AND_UDP 46 }; 47 48 // NOTE: keep these in sync with TrafficStats.java 49 enum IfaceStatType { 50 RX_BYTES = 0, 51 RX_PACKETS = 1, 52 TX_BYTES = 2, 53 TX_PACKETS = 3 54 }; 55 56 struct IfaceStat { 57 uint64_t rxBytes; 58 uint64_t rxPackets; 59 uint64_t txBytes; 60 uint64_t txPackets; 61 }; 62 63 // Returns an ASCII decimal number read from the specified file, -1 on error. 64 static jlong readNumber(char const* filename) { 65 char buf[80]; 66 int fd = open(filename, O_RDONLY); 67 if (fd < 0) { 68 if (errno != ENOENT) ALOGE("Can't open %s: %s", filename, strerror(errno)); 69 return -1; 70 } 71 72 int len = read(fd, buf, sizeof(buf) - 1); 73 if (len < 0) { 74 ALOGE("Can't read %s: %s", filename, strerror(errno)); 75 close(fd); 76 return -1; 77 } 78 79 close(fd); 80 buf[len] = '\0'; 81 return atoll(buf); 82 } 83 84 static int parseIfaceStat(const char* iface, struct IfaceStat* stat) { 85 FILE *fp = fopen(IFACE_STAT_ALL, "r"); 86 if (!fp) { 87 return errno; 88 } 89 90 char buffer[256]; 91 char cur_iface[32]; 92 int active; 93 uint64_t rxBytes, rxPackets, txBytes, txPackets, devRxBytes, devRxPackets, devTxBytes, 94 devTxPackets; 95 96 while (fgets(buffer, 256, fp) != NULL) { 97 if (sscanf(buffer, "%31s %d %llu %llu %llu %llu %llu %llu %llu %llu", cur_iface, &active, 98 &rxBytes, &rxPackets, &txBytes, &txPackets, &devRxBytes, &devRxPackets, 99 &devTxBytes, &devTxPackets) != 10) { 100 continue; 101 } 102 103 if (!iface || !strcmp(iface, cur_iface)) { 104 stat->rxBytes += rxBytes; 105 stat->rxPackets += rxPackets; 106 stat->txBytes += txBytes; 107 stat->txPackets += txPackets; 108 109 if (active) { 110 stat->rxBytes += devRxBytes; 111 stat->rxPackets += devRxPackets; 112 stat->txBytes += devTxBytes; 113 stat->txPackets += devTxPackets; 114 } 115 } 116 } 117 118 fclose(fp); 119 return 0; 120 } 121 122 static uint64_t getIfaceStatType(const char* iface, IfaceStatType type) { 123 struct IfaceStat stat; 124 memset(&stat, 0, sizeof(IfaceStat)); 125 126 if (parseIfaceStat(iface, &stat)) { 127 return VALUE_UNKNOWN; 128 } 129 130 switch (type) { 131 case RX_BYTES: 132 return stat.rxBytes; 133 case RX_PACKETS: 134 return stat.rxPackets; 135 case TX_BYTES: 136 return stat.txBytes; 137 case TX_PACKETS: 138 return stat.txPackets; 139 default: 140 return VALUE_UNKNOWN; 141 } 142 } 143 144 static jlong getTotalStat(JNIEnv* env, jclass clazz, jint type) { 145 return getIfaceStatType(NULL, (IfaceStatType) type); 146 } 147 148 static jlong getIfaceStat(JNIEnv* env, jclass clazz, jstring iface, jint type) { 149 struct IfaceStat stat; 150 const char* ifaceChars = env->GetStringUTFChars(iface, NULL); 151 if (ifaceChars) { 152 uint64_t stat = getIfaceStatType(ifaceChars, (IfaceStatType) type); 153 env->ReleaseStringUTFChars(iface, ifaceChars); 154 return stat; 155 } else { 156 return VALUE_UNKNOWN; 157 } 158 } 159 160 161 // Per-UID stats require reading from a constructed filename. 162 163 static jlong getUidBytes(JNIEnv* env, jobject clazz, jint uid, 164 enum Tx_Rx tx_or_rx, enum Tcp_Udp tcp_or_udp) { 165 char tcp_filename[80], udp_filename[80]; 166 jlong tcp_bytes = -1, udp_bytes = -1, total_bytes = -1; 167 168 switch (tx_or_rx) { 169 case TX: 170 sprintf(tcp_filename, "/proc/uid_stat/%d/tcp_snd", uid); 171 sprintf(udp_filename, "/proc/uid_stat/%d/udp_snd", uid); 172 break; 173 case RX: 174 sprintf(tcp_filename, "/proc/uid_stat/%d/tcp_rcv", uid); 175 sprintf(udp_filename, "/proc/uid_stat/%d/udp_rcv", uid); 176 break; 177 default: 178 return -1; 179 } 180 181 switch (tcp_or_udp) { 182 case TCP: 183 tcp_bytes = readNumber(tcp_filename); 184 total_bytes = (tcp_bytes >= 0) ? tcp_bytes : -1; 185 break; 186 case UDP: 187 udp_bytes = readNumber(udp_filename); 188 total_bytes = (udp_bytes >= 0) ? udp_bytes : -1; 189 break; 190 case TCP_AND_UDP: 191 tcp_bytes = readNumber(tcp_filename); 192 total_bytes += (tcp_bytes >= 0 ? tcp_bytes : 0); 193 194 udp_bytes = readNumber(udp_filename); 195 total_bytes += (udp_bytes >= 0 ? udp_bytes : 0); 196 break; 197 default: 198 return -1; 199 } 200 201 return total_bytes; 202 } 203 204 static jlong getUidPkts(JNIEnv* env, jobject clazz, jint uid, 205 enum Tx_Rx tx_or_rx, enum Tcp_Udp tcp_or_udp) { 206 char tcp_filename[80], udp_filename[80]; 207 jlong tcp_pkts = -1, udp_pkts = -1, total_pkts = -1; 208 209 switch (tx_or_rx) { 210 case TX: 211 sprintf(tcp_filename, "/proc/uid_stat/%d/tcp_snd_pkt", uid); 212 sprintf(udp_filename, "/proc/uid_stat/%d/udp_snd_pkt", uid); 213 break; 214 case RX: 215 sprintf(tcp_filename, "/proc/uid_stat/%d/tcp_rcv_pkt", uid); 216 sprintf(udp_filename, "/proc/uid_stat/%d/udp_rcv_pkt", uid); 217 break; 218 default: 219 return -1; 220 } 221 222 switch (tcp_or_udp) { 223 case TCP: 224 tcp_pkts = readNumber(tcp_filename); 225 total_pkts = (tcp_pkts >= 0) ? tcp_pkts : -1; 226 break; 227 case UDP: 228 udp_pkts = readNumber(udp_filename); 229 total_pkts = (udp_pkts >= 0) ? udp_pkts : -1; 230 break; 231 case TCP_AND_UDP: 232 tcp_pkts = readNumber(tcp_filename); 233 total_pkts += (tcp_pkts >= 0 ? tcp_pkts : 0); 234 235 udp_pkts = readNumber(udp_filename); 236 total_pkts += (udp_pkts >= 0 ? udp_pkts : 0); 237 break; 238 default: 239 return -1; 240 } 241 242 return total_pkts; 243 } 244 245 static jlong getUidRxBytes(JNIEnv* env, jobject clazz, jint uid) { 246 return getUidBytes(env, clazz, uid, RX, TCP_AND_UDP); 247 } 248 249 static jlong getUidTxBytes(JNIEnv* env, jobject clazz, jint uid) { 250 return getUidBytes(env, clazz, uid, TX, TCP_AND_UDP); 251 } 252 253 /* TCP Segments + UDP Packets */ 254 static jlong getUidTxPackets(JNIEnv* env, jobject clazz, jint uid) { 255 return getUidPkts(env, clazz, uid, TX, TCP_AND_UDP); 256 } 257 258 /* TCP Segments + UDP Packets */ 259 static jlong getUidRxPackets(JNIEnv* env, jobject clazz, jint uid) { 260 return getUidPkts(env, clazz, uid, RX, TCP_AND_UDP); 261 } 262 263 static jlong getUidTcpTxBytes(JNIEnv* env, jobject clazz, jint uid) { 264 return getUidBytes(env, clazz, uid, TX, TCP); 265 } 266 267 static jlong getUidTcpRxBytes(JNIEnv* env, jobject clazz, jint uid) { 268 return getUidBytes(env, clazz, uid, RX, TCP); 269 } 270 271 static jlong getUidUdpTxBytes(JNIEnv* env, jobject clazz, jint uid) { 272 return getUidBytes(env, clazz, uid, TX, UDP); 273 } 274 275 static jlong getUidUdpRxBytes(JNIEnv* env, jobject clazz, jint uid) { 276 return getUidBytes(env, clazz, uid, RX, UDP); 277 } 278 279 static jlong getUidTcpTxSegments(JNIEnv* env, jobject clazz, jint uid) { 280 return getUidPkts(env, clazz, uid, TX, TCP); 281 } 282 283 static jlong getUidTcpRxSegments(JNIEnv* env, jobject clazz, jint uid) { 284 return getUidPkts(env, clazz, uid, RX, TCP); 285 } 286 287 static jlong getUidUdpTxPackets(JNIEnv* env, jobject clazz, jint uid) { 288 return getUidPkts(env, clazz, uid, TX, UDP); 289 } 290 291 static jlong getUidUdpRxPackets(JNIEnv* env, jobject clazz, jint uid) { 292 return getUidPkts(env, clazz, uid, RX, UDP); 293 } 294 295 static JNINativeMethod gMethods[] = { 296 {"nativeGetTotalStat", "(I)J", (void*) getTotalStat}, 297 {"nativeGetIfaceStat", "(Ljava/lang/String;I)J", (void*) getIfaceStat}, 298 299 /* Per-UID Stats */ 300 {"getUidTxBytes", "(I)J", (void*) getUidTxBytes}, 301 {"getUidRxBytes", "(I)J", (void*) getUidRxBytes}, 302 {"getUidTxPackets", "(I)J", (void*) getUidTxPackets}, 303 {"getUidRxPackets", "(I)J", (void*) getUidRxPackets}, 304 305 {"getUidTcpTxBytes", "(I)J", (void*) getUidTcpTxBytes}, 306 {"getUidTcpRxBytes", "(I)J", (void*) getUidTcpRxBytes}, 307 {"getUidUdpTxBytes", "(I)J", (void*) getUidUdpTxBytes}, 308 {"getUidUdpRxBytes", "(I)J", (void*) getUidUdpRxBytes}, 309 310 {"getUidTcpTxSegments", "(I)J", (void*) getUidTcpTxSegments}, 311 {"getUidTcpRxSegments", "(I)J", (void*) getUidTcpRxSegments}, 312 {"getUidUdpTxPackets", "(I)J", (void*) getUidUdpTxPackets}, 313 {"getUidUdpRxPackets", "(I)J", (void*) getUidUdpRxPackets}, 314 }; 315 316 int register_android_net_TrafficStats(JNIEnv* env) { 317 return AndroidRuntime::registerNativeMethods(env, "android/net/TrafficStats", 318 gMethods, NELEM(gMethods)); 319 } 320 321 } 322