2016-01-18 21:22:54 +00:00
|
|
|
/*
|
|
|
|
This file is part of NetGuard.
|
|
|
|
|
|
|
|
NetGuard is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
NetGuard is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with NetGuard. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
Copyright 2015-2016 by Marcel Bokhorst (M66B)
|
|
|
|
*/
|
|
|
|
|
2016-01-09 11:10:11 +00:00
|
|
|
#include <jni.h>
|
2016-01-13 08:23:21 +00:00
|
|
|
#include <android/log.h>
|
|
|
|
|
2016-01-09 20:17:42 +00:00
|
|
|
#include <stdio.h>
|
2016-01-15 09:08:18 +00:00
|
|
|
#include <stdlib.h>
|
2016-01-10 07:14:47 +00:00
|
|
|
#include <time.h>
|
2016-01-09 15:56:23 +00:00
|
|
|
#include <unistd.h>
|
2016-01-13 08:23:21 +00:00
|
|
|
#include <pthread.h>
|
|
|
|
|
2016-01-09 15:56:23 +00:00
|
|
|
#include <arpa/inet.h>
|
2016-01-09 11:10:11 +00:00
|
|
|
#include <netinet/ip.h>
|
|
|
|
#include <netinet/ip6.h>
|
2016-01-09 15:56:23 +00:00
|
|
|
#include <netinet/udp.h>
|
|
|
|
#include <netinet/tcp.h>
|
2016-01-09 11:10:11 +00:00
|
|
|
|
2016-01-17 16:41:54 +00:00
|
|
|
#include "netguard.h"
|
|
|
|
|
2016-01-20 08:24:34 +00:00
|
|
|
// #define PROFILE 1
|
2016-01-18 18:37:52 +00:00
|
|
|
|
2016-01-20 09:07:09 +00:00
|
|
|
// TODO TCP options
|
2016-01-12 20:15:25 +00:00
|
|
|
// TODO TCP fragmentation
|
|
|
|
// TODO TCP push
|
2016-01-20 09:07:09 +00:00
|
|
|
// TODO TCPv6
|
2016-01-17 13:20:07 +00:00
|
|
|
// TODO UDPv6
|
2016-01-15 11:57:32 +00:00
|
|
|
// TODO fix warnings
|
2016-01-18 19:28:33 +00:00
|
|
|
// TODO non blocking send/write, handle EAGAIN/EWOULDBLOCK
|
2016-01-15 11:57:32 +00:00
|
|
|
|
|
|
|
// Window size < 2^31: x <= y: (uint32_t)(y-x) < 0x80000000
|
2016-01-16 08:07:04 +00:00
|
|
|
// It is assumed that no packets will get lost and that packets arrive in order
|
|
|
|
|
2016-01-19 19:58:51 +00:00
|
|
|
// http://journals.ecs.soton.ac.uk/java/tutorial/native1.1/implementing/index.html
|
|
|
|
|
2016-01-12 20:15:25 +00:00
|
|
|
// Global variables
|
2016-01-12 12:15:21 +00:00
|
|
|
|
2016-01-13 08:23:21 +00:00
|
|
|
static JavaVM *jvm;
|
|
|
|
pthread_t thread_id;
|
2016-01-14 06:46:23 +00:00
|
|
|
int signaled = 0;
|
2016-01-20 13:11:04 +00:00
|
|
|
struct udp_session *udp_session = NULL;
|
2016-01-20 11:35:51 +00:00
|
|
|
struct tcp_session *tcp_session = NULL;
|
2016-01-19 16:54:07 +00:00
|
|
|
int loglevel = 0;
|
2016-01-17 09:42:21 +00:00
|
|
|
char *pcap_fn = NULL;
|
2016-01-11 22:06:35 +00:00
|
|
|
|
2016-01-13 08:23:21 +00:00
|
|
|
// JNI
|
2016-01-11 22:06:35 +00:00
|
|
|
|
2016-01-14 14:02:32 +00:00
|
|
|
JNIEXPORT void JNICALL
|
2016-01-18 18:37:52 +00:00
|
|
|
Java_eu_faircode_netguard_SinkholeService_jni_1init(JNIEnv *env) {
|
2016-01-20 13:11:04 +00:00
|
|
|
udp_session = NULL;
|
2016-01-20 11:35:51 +00:00
|
|
|
tcp_session = NULL;
|
2016-01-18 18:37:52 +00:00
|
|
|
pcap_fn = NULL;
|
2016-01-17 09:42:21 +00:00
|
|
|
}
|
|
|
|
|
2016-01-09 11:10:11 +00:00
|
|
|
JNIEXPORT void JNICALL
|
2016-01-19 19:58:51 +00:00
|
|
|
Java_eu_faircode_netguard_SinkholeService_jni_1start(
|
|
|
|
JNIEnv *env, jobject instance,
|
|
|
|
jint tun, jintArray uid_,
|
|
|
|
jboolean log, jboolean filter,
|
|
|
|
jint loglevel_) {
|
|
|
|
|
2016-01-18 12:07:00 +00:00
|
|
|
loglevel = loglevel_;
|
2016-01-19 16:54:07 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "Starting tun=%d log %d filter %d level %d",
|
|
|
|
tun, log, filter, loglevel_);
|
2016-01-18 18:37:52 +00:00
|
|
|
|
2016-01-18 20:54:45 +00:00
|
|
|
// Set blocking
|
2016-01-18 18:37:52 +00:00
|
|
|
uint8_t flags = fcntl(tun, F_GETFL, 0);
|
2016-01-18 20:54:45 +00:00
|
|
|
if (flags < 0 || fcntl(tun, F_SETFL, flags & ~O_NONBLOCK) < 0)
|
2016-01-19 08:49:47 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "fcntl tun ~O_NONBLOCK error %d: %s",
|
|
|
|
errno, strerror(errno));
|
2016-01-12 16:19:27 +00:00
|
|
|
|
2016-01-14 06:46:23 +00:00
|
|
|
if (pthread_kill(thread_id, 0) == 0)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "Already running thread %lu", thread_id);
|
2016-01-14 06:46:23 +00:00
|
|
|
else {
|
|
|
|
jint rs = (*env)->GetJavaVM(env, &jvm);
|
|
|
|
if (rs != JNI_OK)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "GetJavaVM failed");
|
2016-01-14 06:46:23 +00:00
|
|
|
|
2016-01-19 19:58:51 +00:00
|
|
|
// Get arguments
|
2016-01-14 06:46:23 +00:00
|
|
|
struct arguments *args = malloc(sizeof(struct arguments));
|
|
|
|
args->instance = (*env)->NewGlobalRef(env, instance);
|
|
|
|
args->tun = tun;
|
2016-01-19 19:58:51 +00:00
|
|
|
args->count = (*env)->GetArrayLength(env, uid_);
|
|
|
|
args->uid = malloc(args->count * sizeof(jint));
|
|
|
|
jint *uid = (*env)->GetIntArrayElements(env, uid_, NULL);
|
|
|
|
memcpy(args->uid, uid, args->count * sizeof(jint));
|
|
|
|
(*env)->ReleaseIntArrayElements(env, uid_, uid, 0);
|
2016-01-19 16:54:07 +00:00
|
|
|
args->log = log;
|
|
|
|
args->filter = filter;
|
2016-01-19 19:58:51 +00:00
|
|
|
|
|
|
|
for (int i = 0; i < args->count; i++)
|
2016-01-20 08:24:34 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "Allowed uid %d", args->uid[i]);
|
2016-01-19 19:58:51 +00:00
|
|
|
|
|
|
|
// Start native thread
|
|
|
|
int err = pthread_create(&thread_id, NULL, handle_events, (void *) args);
|
2016-01-17 13:20:07 +00:00
|
|
|
if (err == 0)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "Started thread %lu", thread_id);
|
2016-01-17 13:20:07 +00:00
|
|
|
else
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "pthread_create error %d: %s", err, strerror(err));
|
2016-01-14 06:46:23 +00:00
|
|
|
}
|
2016-01-12 12:15:21 +00:00
|
|
|
}
|
|
|
|
|
2016-01-09 11:10:11 +00:00
|
|
|
JNIEXPORT void JNICALL
|
2016-01-17 05:35:26 +00:00
|
|
|
Java_eu_faircode_netguard_SinkholeService_jni_1stop(JNIEnv *env, jobject instance,
|
|
|
|
jint tun, jboolean clear) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "Stop tun %d clear %d", tun, (int) clear);
|
2016-01-14 06:46:23 +00:00
|
|
|
if (pthread_kill(thread_id, 0) == 0) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "Kill thread %lu", thread_id);
|
2016-01-13 11:15:46 +00:00
|
|
|
int err = pthread_kill(thread_id, SIGUSR1);
|
|
|
|
if (err != 0)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "pthread_kill error %d: %s", err, strerror(err));
|
2016-01-14 06:46:23 +00:00
|
|
|
else {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "Join thread %lu", thread_id);
|
2016-01-14 06:46:23 +00:00
|
|
|
pthread_join(thread_id, NULL);
|
|
|
|
if (err != 0)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "pthread_join error %d: %s", err, strerror(err));
|
2016-01-14 06:46:23 +00:00
|
|
|
}
|
2016-01-20 08:24:34 +00:00
|
|
|
if (clear)
|
|
|
|
clear_sessions();
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "Stopped thread %lu", thread_id);
|
2016-01-13 11:15:46 +00:00
|
|
|
} else
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "Not running");
|
2016-01-09 11:10:11 +00:00
|
|
|
}
|
|
|
|
|
2016-01-17 09:42:21 +00:00
|
|
|
JNIEXPORT void JNICALL
|
|
|
|
Java_eu_faircode_netguard_SinkholeService_jni_1done(JNIEnv *env, jobject instance) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "Done");
|
|
|
|
|
2016-01-20 08:24:34 +00:00
|
|
|
clear_sessions();
|
2016-01-18 18:37:52 +00:00
|
|
|
|
|
|
|
if (pcap_fn != NULL)
|
|
|
|
free(pcap_fn);
|
2016-01-17 09:42:21 +00:00
|
|
|
}
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
JNIEXPORT void JNICALL
|
|
|
|
Java_eu_faircode_netguard_SinkholeService_jni_1pcap(JNIEnv *env, jclass type, jstring name_) {
|
|
|
|
// TODO limit pcap file size
|
|
|
|
// TODO keep pcap file open
|
|
|
|
|
|
|
|
if (name_ == NULL) {
|
|
|
|
pcap_fn = NULL;
|
|
|
|
log_android(ANDROID_LOG_INFO, "PCAP disabled");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
const char *name = (*env)->GetStringUTFChars(env, name_, 0);
|
|
|
|
log_android(ANDROID_LOG_INFO, "PCAP file %s", name);
|
|
|
|
|
|
|
|
const char *tmp = malloc(strlen(name) + 1);
|
|
|
|
strcpy(tmp, name);
|
|
|
|
pcap_fn = tmp;
|
|
|
|
|
2016-01-18 20:37:51 +00:00
|
|
|
write_pcap_hdr();
|
2016-01-18 18:37:52 +00:00
|
|
|
|
|
|
|
(*env)->ReleaseStringUTFChars(env, name_, name);
|
|
|
|
}
|
|
|
|
}
|
2016-01-20 08:24:34 +00:00
|
|
|
|
2016-01-11 22:06:35 +00:00
|
|
|
// Private functions
|
|
|
|
|
2016-01-20 08:24:34 +00:00
|
|
|
void clear_sessions() {
|
2016-01-20 13:11:04 +00:00
|
|
|
struct udp_session *u = udp_session;
|
|
|
|
while (u != NULL) {
|
|
|
|
close(u->socket);
|
|
|
|
struct udp_session *p = u;
|
|
|
|
u = u->next;
|
|
|
|
free(p);
|
|
|
|
}
|
|
|
|
udp_session = NULL;
|
|
|
|
|
|
|
|
struct tcp_session *t = tcp_session;
|
|
|
|
while (t != NULL) {
|
|
|
|
close(t->socket);
|
|
|
|
struct tcp_session *p = t;
|
|
|
|
t = t->next;
|
2016-01-20 08:24:34 +00:00
|
|
|
free(p);
|
|
|
|
}
|
2016-01-20 11:35:51 +00:00
|
|
|
tcp_session = NULL;
|
2016-01-20 08:24:34 +00:00
|
|
|
}
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
void handle_signal(int sig, siginfo_t *info, void *context) {
|
|
|
|
log_android(ANDROID_LOG_DEBUG, "Signal %d", sig);
|
2016-01-14 06:46:23 +00:00
|
|
|
signaled = 1;
|
2016-01-13 11:15:46 +00:00
|
|
|
}
|
|
|
|
|
2016-01-18 11:19:40 +00:00
|
|
|
void handle_events(void *a) {
|
2016-01-13 08:23:21 +00:00
|
|
|
fd_set rfds;
|
|
|
|
fd_set wfds;
|
|
|
|
fd_set efds;
|
2016-01-13 11:15:46 +00:00
|
|
|
struct timespec ts;
|
|
|
|
sigset_t blockset;
|
|
|
|
sigset_t emptyset;
|
|
|
|
struct sigaction sa;
|
|
|
|
|
2016-01-18 11:19:40 +00:00
|
|
|
struct arguments *args = (struct arguments *) a;
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "Start events tun=%d thread %lu", args->tun, thread_id);
|
2016-01-18 11:19:40 +00:00
|
|
|
|
|
|
|
// Attach to Java
|
|
|
|
JNIEnv *env;
|
|
|
|
jint rs = (*jvm)->AttachCurrentThread(jvm, &env, NULL);
|
|
|
|
if (rs != JNI_OK) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "AttachCurrentThread failed");
|
2016-01-18 11:19:40 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
args->env = env;
|
|
|
|
|
2016-01-13 11:15:46 +00:00
|
|
|
// Block SIGUSR1
|
|
|
|
sigemptyset(&blockset);
|
|
|
|
sigaddset(&blockset, SIGUSR1);
|
|
|
|
sigprocmask(SIG_BLOCK, &blockset, NULL);
|
|
|
|
|
|
|
|
/// Handle SIGUSR1
|
2016-01-18 18:37:52 +00:00
|
|
|
sa.sa_sigaction = handle_signal;
|
2016-01-13 11:15:46 +00:00
|
|
|
sigemptyset(&sa.sa_mask);
|
|
|
|
sa.sa_flags = SA_RESTART;
|
|
|
|
sigaction(SIGUSR1, &sa, NULL);
|
|
|
|
|
2016-01-14 06:46:23 +00:00
|
|
|
signaled = 0;
|
|
|
|
|
2016-01-13 11:15:46 +00:00
|
|
|
// Loop
|
|
|
|
while (1) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "Loop thread %lu", thread_id);
|
2016-01-13 08:23:21 +00:00
|
|
|
|
|
|
|
// Select
|
2016-01-18 19:57:49 +00:00
|
|
|
ts.tv_sec = SELECT_TIMEOUT;
|
2016-01-13 11:15:46 +00:00
|
|
|
ts.tv_nsec = 0;
|
|
|
|
sigemptyset(&emptyset);
|
2016-01-20 13:11:04 +00:00
|
|
|
int max = get_selects(args, &rfds, &wfds, &efds);
|
2016-01-20 11:40:26 +00:00
|
|
|
int ready = pselect(max + 1, &rfds, &wfds, &efds,
|
2016-01-20 13:11:04 +00:00
|
|
|
udp_session == NULL && tcp_session == NULL ? NULL : &ts,
|
|
|
|
&emptyset);
|
2016-01-13 08:23:21 +00:00
|
|
|
if (ready < 0) {
|
2016-01-13 11:15:46 +00:00
|
|
|
if (errno == EINTR) {
|
2016-01-14 06:46:23 +00:00
|
|
|
if (signaled) { ;
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "pselect signaled");
|
2016-01-14 06:46:23 +00:00
|
|
|
break;
|
|
|
|
} else {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "pselect interrupted");
|
2016-01-14 06:46:23 +00:00
|
|
|
continue;
|
|
|
|
}
|
2016-01-13 11:15:46 +00:00
|
|
|
} else {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "pselect error %d: %s",
|
|
|
|
errno, strerror(errno));
|
2016-01-14 06:46:23 +00:00
|
|
|
break;
|
2016-01-13 11:15:46 +00:00
|
|
|
}
|
2016-01-13 08:23:21 +00:00
|
|
|
}
|
|
|
|
|
2016-01-18 11:19:40 +00:00
|
|
|
// Count sessions
|
2016-01-20 13:11:04 +00:00
|
|
|
int us = 0;
|
|
|
|
struct udp_session *u = udp_session;
|
|
|
|
while (u != NULL) {
|
|
|
|
us++;
|
|
|
|
u = u->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ts = 0;
|
|
|
|
struct tcp_session *t = tcp_session;
|
|
|
|
while (t != NULL) {
|
|
|
|
ts++;
|
|
|
|
t = t->next;
|
2016-01-16 19:58:12 +00:00
|
|
|
}
|
|
|
|
|
2016-01-13 08:23:21 +00:00
|
|
|
if (ready == 0)
|
2016-01-20 13:11:04 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "pselect timeout udp %d tcp %d", us, ts);
|
2016-01-13 08:23:21 +00:00
|
|
|
else {
|
2016-01-20 13:11:04 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "pselect udp %d tcp %d ready %d", us, ts, ready);
|
2016-01-18 18:37:52 +00:00
|
|
|
|
|
|
|
#ifdef PROFILE
|
|
|
|
struct timeval start, end;
|
|
|
|
float mselapsed;
|
|
|
|
gettimeofday(&start, NULL);
|
|
|
|
#endif
|
2016-01-16 19:58:12 +00:00
|
|
|
|
2016-01-18 11:19:40 +00:00
|
|
|
// Check upstream
|
2016-01-20 13:11:04 +00:00
|
|
|
if (check_tun(args, &rfds, &wfds, &efds) < 0)
|
2016-01-19 19:58:51 +00:00
|
|
|
break;
|
2016-01-12 08:45:58 +00:00
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
#ifdef PROFILE
|
|
|
|
gettimeofday(&end, NULL);
|
|
|
|
mselapsed = (end.tv_sec - start.tv_sec) * 1000.0 +
|
|
|
|
(end.tv_usec - start.tv_usec) / 1000.0;
|
|
|
|
if (mselapsed > 1)
|
|
|
|
log_android(ANDROID_LOG_INFO, "tun %f", mselapsed);
|
|
|
|
|
|
|
|
gettimeofday(&start, NULL);
|
|
|
|
#endif
|
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
// Check UDP downstream
|
|
|
|
check_udp_sockets(args, &rfds, &wfds, &efds);
|
2016-01-20 08:24:34 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
// Check TCP downstream
|
|
|
|
check_tcp_sockets(args, &rfds, &wfds, &efds);
|
2016-01-18 18:37:52 +00:00
|
|
|
|
|
|
|
#ifdef PROFILE
|
|
|
|
gettimeofday(&end, NULL);
|
|
|
|
mselapsed = (end.tv_sec - start.tv_sec) * 1000.0 +
|
|
|
|
(end.tv_usec - start.tv_usec) / 1000.0;
|
|
|
|
if (mselapsed > 1)
|
|
|
|
log_android(ANDROID_LOG_INFO, "sockets %f", mselapsed);
|
|
|
|
#endif
|
2016-01-20 08:24:34 +00:00
|
|
|
}
|
2016-01-18 11:19:40 +00:00
|
|
|
}
|
2016-01-17 09:42:21 +00:00
|
|
|
|
2016-01-19 19:58:51 +00:00
|
|
|
free(args->uid);
|
|
|
|
free(args);
|
|
|
|
|
2016-01-18 11:19:40 +00:00
|
|
|
(*env)->DeleteGlobalRef(env, args->instance);
|
|
|
|
rs = (*jvm)->DetachCurrentThread(jvm);
|
|
|
|
if (rs != JNI_OK)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "DetachCurrentThread failed");
|
2016-01-18 11:19:40 +00:00
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "Stopped events tun=%d thread %lu", args->tun, thread_id);
|
2016-01-18 20:37:51 +00:00
|
|
|
// TODO report exit to Java
|
2016-01-18 11:19:40 +00:00
|
|
|
}
|
2016-01-17 09:42:21 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
int get_selects(const struct arguments *args, fd_set *rfds, fd_set *wfds, fd_set *efds) {
|
2016-01-18 11:19:40 +00:00
|
|
|
time_t now = time(NULL);
|
2016-01-17 09:42:21 +00:00
|
|
|
|
2016-01-20 08:24:34 +00:00
|
|
|
// Initialize
|
2016-01-18 11:19:40 +00:00
|
|
|
FD_ZERO(rfds);
|
|
|
|
FD_ZERO(wfds);
|
|
|
|
FD_ZERO(efds);
|
2016-01-17 09:42:21 +00:00
|
|
|
|
2016-01-20 08:24:34 +00:00
|
|
|
// Always select tun
|
2016-01-18 11:19:40 +00:00
|
|
|
FD_SET(args->tun, rfds);
|
|
|
|
FD_SET(args->tun, efds);
|
|
|
|
int max = args->tun;
|
2016-01-17 09:42:21 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
// Select UDP sockets
|
|
|
|
struct udp_session *ul = NULL;
|
|
|
|
struct udp_session *u = udp_session;
|
|
|
|
while (u != NULL) {
|
|
|
|
if (u->time + UDP_TIMEOUT < now) {
|
|
|
|
log_android(ANDROID_LOG_INFO, "UDP timeout");
|
2016-01-20 08:24:34 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
// TODO non blocking?
|
|
|
|
if (close(u->socket))
|
|
|
|
log_android(ANDROID_LOG_ERROR, "UDP close error %d: %s", errno, strerror(errno));
|
|
|
|
|
|
|
|
if (ul == NULL)
|
|
|
|
udp_session = u->next;
|
|
|
|
else
|
|
|
|
ul->next = u->next;
|
|
|
|
|
|
|
|
struct udp_session *c = u;
|
|
|
|
u = u->next;
|
|
|
|
free(c);
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
FD_SET(u->socket, efds);
|
|
|
|
FD_SET(u->socket, rfds);
|
|
|
|
if (u->socket > max)
|
|
|
|
max = u->socket;
|
|
|
|
}
|
|
|
|
|
|
|
|
ul = u;
|
|
|
|
u = u->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Select TCP sockets
|
|
|
|
struct tcp_session *tl = NULL;
|
|
|
|
struct tcp_session *t = tcp_session;
|
|
|
|
while (t != NULL) {
|
2016-01-18 19:57:49 +00:00
|
|
|
int timeout = 0;
|
2016-01-20 13:11:04 +00:00
|
|
|
if (t->state == TCP_LISTEN || t->state == TCP_SYN_RECV)
|
2016-01-18 19:57:49 +00:00
|
|
|
timeout = TCP_INIT_TIMEOUT;
|
2016-01-20 13:11:04 +00:00
|
|
|
else if (t->state == TCP_ESTABLISHED)
|
2016-01-18 19:57:49 +00:00
|
|
|
timeout = TCP_IDLE_TIMEOUT;
|
|
|
|
else
|
|
|
|
timeout = TCP_CLOSE_TIMEOUT;
|
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
if (t->state != TCP_TIME_WAIT && t->time + timeout < now) {
|
2016-01-18 11:19:40 +00:00
|
|
|
// TODO send keep alives?
|
|
|
|
char dest[20];
|
2016-01-20 13:11:04 +00:00
|
|
|
inet_ntop(AF_INET, &(t->daddr), dest, sizeof(dest));
|
2016-01-18 14:29:01 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "Idle %s/%u lport %u", dest, ntohs(t->dest), t->lport);
|
2016-01-12 08:45:58 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
write_rst(t, args->tun);
|
2016-01-18 11:19:40 +00:00
|
|
|
}
|
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
if (t->state == TCP_TIME_WAIT) {
|
2016-01-18 11:19:40 +00:00
|
|
|
// Log
|
|
|
|
char dest[20];
|
2016-01-20 13:11:04 +00:00
|
|
|
inet_ntop(AF_INET, &(t->daddr), dest, sizeof(dest));
|
|
|
|
log_android(ANDROID_LOG_INFO, "Close %s/%u lport %u", dest, ntohs(t->dest), t->lport);
|
2016-01-18 11:19:40 +00:00
|
|
|
|
2016-01-18 19:57:49 +00:00
|
|
|
// TODO keep for some time?
|
2016-01-18 11:19:40 +00:00
|
|
|
|
|
|
|
// TODO non blocking?
|
2016-01-20 13:11:04 +00:00
|
|
|
if (close(t->socket))
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "close error %d: %s", errno, strerror(errno));
|
2016-01-18 11:19:40 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
if (tl == NULL)
|
|
|
|
tcp_session = t->next;
|
2016-01-18 11:19:40 +00:00
|
|
|
else
|
2016-01-20 13:11:04 +00:00
|
|
|
tl->next = t->next;
|
2016-01-18 11:19:40 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
struct tcp_session *c = t;
|
|
|
|
t = t->next;
|
2016-01-18 11:19:40 +00:00
|
|
|
free(c);
|
|
|
|
continue;
|
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
} else if (t->state == TCP_LISTEN) {
|
2016-01-18 14:29:01 +00:00
|
|
|
// Check for connected / errors
|
2016-01-20 13:11:04 +00:00
|
|
|
FD_SET(t->socket, efds);
|
|
|
|
FD_SET(t->socket, wfds);
|
|
|
|
if (t->socket > max)
|
|
|
|
max = t->socket;
|
2016-01-18 14:29:01 +00:00
|
|
|
}
|
2016-01-20 13:11:04 +00:00
|
|
|
else if (t->state == TCP_ESTABLISHED ||
|
|
|
|
t->state == TCP_SYN_RECV ||
|
|
|
|
t->state == TCP_CLOSE_WAIT) {
|
2016-01-18 14:29:01 +00:00
|
|
|
// Check for data / errors
|
2016-01-20 13:11:04 +00:00
|
|
|
FD_SET(t->socket, efds);
|
|
|
|
FD_SET(t->socket, rfds);
|
|
|
|
if (t->socket > max)
|
|
|
|
max = t->socket;
|
2016-01-11 22:06:35 +00:00
|
|
|
}
|
2016-01-18 11:19:40 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
tl = t;
|
|
|
|
t = t->next;
|
2016-01-11 22:06:35 +00:00
|
|
|
}
|
2016-01-18 14:29:01 +00:00
|
|
|
|
2016-01-18 11:19:40 +00:00
|
|
|
return max;
|
|
|
|
}
|
2016-01-12 16:19:27 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
int check_tun(const struct arguments *args, fd_set *rfds, fd_set *wfds,
|
2016-01-20 08:24:34 +00:00
|
|
|
fd_set *efds) {
|
2016-01-18 14:29:01 +00:00
|
|
|
// Check tun error
|
2016-01-18 11:19:40 +00:00
|
|
|
if (FD_ISSET(args->tun, efds)) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "tun exception");
|
2016-01-18 11:19:40 +00:00
|
|
|
return -1; // over and out
|
|
|
|
}
|
2016-01-13 08:23:21 +00:00
|
|
|
|
2016-01-18 11:19:40 +00:00
|
|
|
// Check tun read
|
|
|
|
if (FD_ISSET(args->tun, rfds)) {
|
2016-01-18 19:57:49 +00:00
|
|
|
uint8_t buffer[MAX_PKTSIZE];
|
|
|
|
ssize_t length = read(args->tun, buffer, sizeof(buffer));
|
2016-01-18 11:19:40 +00:00
|
|
|
if (length < 0) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "tun read error %d: %s", errno, strerror(errno));
|
2016-01-18 14:29:01 +00:00
|
|
|
return (errno == EINTR ? 0 : -1);
|
2016-01-18 11:19:40 +00:00
|
|
|
}
|
|
|
|
else if (length > 0) {
|
|
|
|
// Write pcap record
|
2016-01-19 16:54:07 +00:00
|
|
|
if (pcap_fn != NULL)
|
2016-01-18 20:37:51 +00:00
|
|
|
write_pcap_rec(buffer, length);
|
2016-01-18 11:19:40 +00:00
|
|
|
|
|
|
|
// Handle IP from tun
|
2016-01-20 13:11:04 +00:00
|
|
|
handle_ip(args, buffer, length);
|
2016-01-18 11:19:40 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-01-18 14:29:01 +00:00
|
|
|
// tun eof
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "tun empty read");
|
2016-01-18 14:29:01 +00:00
|
|
|
return -1;
|
2016-01-18 11:19:40 +00:00
|
|
|
}
|
|
|
|
}
|
2016-01-18 14:29:01 +00:00
|
|
|
|
2016-01-18 11:19:40 +00:00
|
|
|
return 0;
|
2016-01-11 22:06:35 +00:00
|
|
|
}
|
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
void check_udp_sockets(const struct arguments *args, fd_set *rfds, fd_set *wfds, fd_set *efds) {
|
|
|
|
struct udp_session *cur = udp_session;
|
|
|
|
while (cur != NULL) {
|
|
|
|
// Check socket error
|
|
|
|
if (FD_ISSET(cur->socket, efds)) {
|
|
|
|
cur->time = time(NULL);
|
2016-01-20 11:14:15 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
int serr = 0;
|
|
|
|
socklen_t optlen = sizeof(int);
|
|
|
|
int err = getsockopt(cur->socket, SOL_SOCKET, SO_ERROR, &serr, &optlen);
|
|
|
|
if (err < 0)
|
|
|
|
log_android(ANDROID_LOG_ERROR, "UDP getsockopt error %d: %s",
|
|
|
|
errno, strerror(errno));
|
|
|
|
else if (serr)
|
|
|
|
log_android(ANDROID_LOG_ERROR, "UDP SO_ERROR %d: %s", serr, strerror(serr));
|
|
|
|
|
|
|
|
// TODO state
|
|
|
|
}
|
2016-01-20 11:14:15 +00:00
|
|
|
else {
|
2016-01-20 13:11:04 +00:00
|
|
|
// Check socket read
|
|
|
|
if (FD_ISSET(cur->socket, rfds)) {
|
|
|
|
cur->time = time(NULL);
|
2016-01-20 08:24:34 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
uint8_t buffer[MAX_DATASIZE4];
|
|
|
|
ssize_t bytes = recv(cur->socket, buffer, sizeof(buffer), 0);
|
|
|
|
if (bytes < 0) {
|
|
|
|
// Socket error
|
|
|
|
log_android(ANDROID_LOG_ERROR, "UDP recv error %d: %s", errno, strerror(errno));
|
|
|
|
|
|
|
|
if (errno != EINTR); // TODO state
|
|
|
|
}
|
|
|
|
else if (bytes == 0) {
|
|
|
|
// Socket eof
|
|
|
|
log_android(ANDROID_LOG_INFO, "UDP recv empty");
|
|
|
|
// TODO state
|
|
|
|
|
|
|
|
} else {
|
|
|
|
// Socket read data
|
|
|
|
char dest[20];
|
|
|
|
inet_ntop(AF_INET, &(cur->daddr), dest, sizeof(dest));
|
|
|
|
log_android(ANDROID_LOG_INFO, "UDP recv bytes %d for %s/%u @tun",
|
|
|
|
bytes, dest, ntohs(cur->dest));
|
|
|
|
write_udp(cur, buffer, bytes, args->tun);
|
2016-01-20 11:14:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-01-20 13:11:04 +00:00
|
|
|
|
|
|
|
cur = cur->next;
|
2016-01-20 08:24:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
void check_tcp_sockets(const struct arguments *args, fd_set *rfds, fd_set *wfds, fd_set *efds) {
|
2016-01-20 11:35:51 +00:00
|
|
|
struct tcp_session *cur = tcp_session;
|
2016-01-17 16:39:11 +00:00
|
|
|
while (cur != NULL) {
|
2016-01-18 18:37:52 +00:00
|
|
|
int oldstate = cur->state;
|
|
|
|
uint32_t oldlocal = cur->local_seq;
|
|
|
|
uint32_t oldremote = cur->remote_seq;
|
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
// Check socket error
|
2016-01-17 16:39:11 +00:00
|
|
|
if (FD_ISSET(cur->socket, efds)) {
|
2016-01-20 11:40:26 +00:00
|
|
|
cur->time = time(NULL);
|
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
int serr = 0;
|
2016-01-17 16:39:11 +00:00
|
|
|
socklen_t optlen = sizeof(int);
|
|
|
|
int err = getsockopt(cur->socket, SOL_SOCKET, SO_ERROR, &serr, &optlen);
|
|
|
|
if (err < 0)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "getsockopt lport %u error %d: %s",
|
|
|
|
cur->lport, errno, strerror(errno));
|
2016-01-18 14:29:01 +00:00
|
|
|
else if (serr)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "lport %u SO_ERROR %d: %s",
|
|
|
|
cur->lport, serr, strerror(serr));
|
2016-01-17 19:40:40 +00:00
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
write_rst(cur, args->tun);
|
2016-01-17 16:39:11 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Assume socket okay
|
|
|
|
if (cur->state == TCP_LISTEN) {
|
|
|
|
// Check socket connect
|
|
|
|
if (FD_ISSET(cur->socket, wfds)) {
|
2016-01-20 11:40:26 +00:00
|
|
|
cur->time = time(NULL);
|
|
|
|
|
2016-01-17 16:39:11 +00:00
|
|
|
// Log
|
|
|
|
char dest[20];
|
|
|
|
inet_ntop(AF_INET, &(cur->daddr), dest, sizeof(dest));
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "Connected %s/%u lport %u",
|
|
|
|
dest, ntohs(cur->dest), cur->lport);
|
2016-01-17 16:39:11 +00:00
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
if (write_syn_ack(cur, args->tun) >= 0) {
|
2016-01-17 16:39:11 +00:00
|
|
|
cur->local_seq++; // local SYN
|
|
|
|
cur->remote_seq++; // remote SYN
|
|
|
|
cur->state = TCP_SYN_RECV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (cur->state == TCP_SYN_RECV ||
|
|
|
|
cur->state == TCP_ESTABLISHED ||
|
|
|
|
cur->state == TCP_CLOSE_WAIT) {
|
|
|
|
// Check socket read
|
|
|
|
if (FD_ISSET(cur->socket, rfds)) {
|
2016-01-20 11:40:26 +00:00
|
|
|
cur->time = time(NULL);
|
|
|
|
|
2016-01-17 16:39:11 +00:00
|
|
|
// TODO window size
|
2016-01-18 19:57:49 +00:00
|
|
|
uint8_t buffer[MAX_DATASIZE4];
|
|
|
|
ssize_t bytes = recv(cur->socket, buffer, sizeof(buffer), 0);
|
2016-01-17 16:39:11 +00:00
|
|
|
if (bytes < 0) {
|
|
|
|
// Socket error
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "recv lport %u error %d: %s",
|
|
|
|
cur->lport, errno, strerror(errno));
|
2016-01-17 19:40:40 +00:00
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
if (errno != EINTR)
|
|
|
|
write_rst(cur, args->tun);
|
2016-01-17 16:39:11 +00:00
|
|
|
}
|
|
|
|
else if (bytes == 0) {
|
2016-01-18 14:29:01 +00:00
|
|
|
// Socket eof
|
|
|
|
// TCP: application close
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "recv empty lport %u state %s",
|
|
|
|
cur->lport, strstate(cur->state));
|
2016-01-17 16:39:11 +00:00
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
if (write_fin(cur, args->tun) >= 0) {
|
2016-01-17 16:39:11 +00:00
|
|
|
cur->local_seq++; // local FIN
|
2016-01-18 14:29:01 +00:00
|
|
|
|
2016-01-17 16:39:11 +00:00
|
|
|
if (cur->state == TCP_SYN_RECV || cur->state == TCP_ESTABLISHED)
|
|
|
|
cur->state = TCP_FIN_WAIT1;
|
2016-01-17 19:40:40 +00:00
|
|
|
else if (cur->state == TCP_CLOSE_WAIT)
|
2016-01-17 16:39:11 +00:00
|
|
|
cur->state = TCP_LAST_ACK;
|
2016-01-17 19:40:40 +00:00
|
|
|
else
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "Unknown state %s",
|
|
|
|
strstate(cur->state));
|
2016-01-18 14:29:01 +00:00
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "Half close state %s",
|
|
|
|
strstate(cur->state));
|
2016-01-17 16:39:11 +00:00
|
|
|
}
|
|
|
|
} else {
|
2016-01-18 14:29:01 +00:00
|
|
|
// Socket read data
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG,
|
|
|
|
"recv lport %u bytes %d state %s",
|
|
|
|
cur->lport, bytes, strstate(cur->state));
|
2016-01-17 19:40:40 +00:00
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
// Forward to tun
|
|
|
|
if (write_data(cur, buffer, bytes, args->tun) >= 0)
|
|
|
|
cur->local_seq += bytes;
|
2016-01-17 16:39:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-20 08:24:34 +00:00
|
|
|
if (cur->state != oldstate || cur->local_seq != oldlocal ||
|
|
|
|
cur->remote_seq != oldremote) {
|
2016-01-18 18:37:52 +00:00
|
|
|
char dest[20];
|
|
|
|
inet_ntop(AF_INET, &(cur->daddr), dest, sizeof(dest));
|
|
|
|
log_android(ANDROID_LOG_INFO,
|
|
|
|
"Session %s/%u lport %u new state %s local %u remote %u",
|
|
|
|
dest, ntohs(cur->dest), cur->lport, strstate(cur->state),
|
|
|
|
cur->local_seq - cur->local_start,
|
|
|
|
cur->remote_seq - cur->remote_start);
|
|
|
|
}
|
|
|
|
|
2016-01-17 16:39:11 +00:00
|
|
|
cur = cur->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
void handle_ip(const struct arguments *args, const uint8_t *buffer, const uint16_t length) {
|
2016-01-15 18:51:07 +00:00
|
|
|
uint8_t protocol;
|
|
|
|
void *saddr;
|
|
|
|
void *daddr;
|
|
|
|
char source[40];
|
|
|
|
char dest[40];
|
|
|
|
char flags[10];
|
|
|
|
int flen = 0;
|
|
|
|
uint8_t *payload;
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
#ifdef PROFILE
|
|
|
|
float mselapsed;
|
|
|
|
struct timeval start, end;
|
|
|
|
gettimeofday(&start, NULL);
|
|
|
|
#endif
|
|
|
|
|
2016-01-15 18:51:07 +00:00
|
|
|
// Get protocol, addresses & payload
|
|
|
|
uint8_t version = (*buffer) >> 4;
|
|
|
|
if (version == 4) {
|
|
|
|
struct iphdr *ip4hdr = buffer;
|
|
|
|
|
|
|
|
protocol = ip4hdr->protocol;
|
|
|
|
saddr = &ip4hdr->saddr;
|
|
|
|
daddr = &ip4hdr->daddr;
|
|
|
|
|
2016-01-18 20:18:23 +00:00
|
|
|
if (ip4hdr->frag_off & IP_MF) {
|
|
|
|
log_android(ANDROID_LOG_ERROR, "IP fragment");
|
2016-01-15 18:51:07 +00:00
|
|
|
flags[flen++] = '+';
|
2016-01-18 20:18:23 +00:00
|
|
|
}
|
2016-01-15 18:51:07 +00:00
|
|
|
|
2016-01-18 20:18:23 +00:00
|
|
|
uint8_t ipoptlen = (ip4hdr->ihl - 5) * 4;
|
|
|
|
payload = buffer + sizeof(struct iphdr) + ipoptlen;
|
2016-01-15 18:51:07 +00:00
|
|
|
|
|
|
|
if (ntohs(ip4hdr->tot_len) != length) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "Invalid length %u header length %u",
|
|
|
|
length, ntohs(ip4hdr->tot_len));
|
2016-01-15 18:51:07 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
uint16_t csum = calc_checksum(ip4hdr, sizeof(struct iphdr));
|
2016-01-15 18:51:07 +00:00
|
|
|
if (csum != 0) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "Invalid IP checksum");
|
2016-01-15 18:51:07 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (version == 6) {
|
|
|
|
struct ip6_hdr *ip6hdr = buffer;
|
|
|
|
|
|
|
|
protocol = ip6hdr->ip6_nxt;
|
|
|
|
saddr = &ip6hdr->ip6_src;
|
|
|
|
daddr = &ip6hdr->ip6_dst;
|
|
|
|
|
|
|
|
payload = buffer + 40;
|
|
|
|
|
|
|
|
// TODO check length
|
|
|
|
// TODO checksum
|
|
|
|
}
|
|
|
|
else {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "Unknown version %d", version);
|
2016-01-15 18:51:07 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
inet_ntop(version == 4 ? AF_INET : AF_INET6, saddr, source, sizeof(source));
|
|
|
|
inet_ntop(version == 4 ? AF_INET : AF_INET6, daddr, dest, sizeof(dest));
|
|
|
|
|
|
|
|
// Get ports & flags
|
|
|
|
int syn = 0;
|
2016-01-19 20:16:54 +00:00
|
|
|
int32_t sport = -1;
|
|
|
|
int32_t dport = -1;
|
2016-01-15 18:51:07 +00:00
|
|
|
if (protocol == IPPROTO_TCP) {
|
|
|
|
struct tcphdr *tcp = payload;
|
|
|
|
|
|
|
|
sport = ntohs(tcp->source);
|
|
|
|
dport = ntohs(tcp->dest);
|
|
|
|
|
|
|
|
if (tcp->syn) {
|
|
|
|
syn = 1;
|
|
|
|
flags[flen++] = 'S';
|
|
|
|
}
|
|
|
|
if (tcp->ack)
|
|
|
|
flags[flen++] = 'A';
|
|
|
|
if (tcp->psh)
|
|
|
|
flags[flen++] = 'P';
|
|
|
|
if (tcp->fin)
|
|
|
|
flags[flen++] = 'F';
|
2016-01-17 09:42:21 +00:00
|
|
|
if (tcp->rst)
|
2016-01-15 18:51:07 +00:00
|
|
|
flags[flen++] = 'R';
|
|
|
|
|
|
|
|
// TODO checksum
|
|
|
|
} else if (protocol == IPPROTO_UDP) {
|
|
|
|
struct udphdr *udp = payload;
|
|
|
|
|
|
|
|
sport = ntohs(udp->source);
|
|
|
|
dport = ntohs(udp->dest);
|
|
|
|
|
|
|
|
// TODO checksum
|
|
|
|
}
|
|
|
|
flags[flen] = 0;
|
|
|
|
|
|
|
|
// Get uid
|
|
|
|
jint uid = -1;
|
2016-01-19 20:10:48 +00:00
|
|
|
if ((protocol == IPPROTO_TCP && (!args->filter || syn)) || protocol == IPPROTO_UDP) {
|
2016-01-20 09:27:18 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "get uid %s/%u syn %d", dest, dport, syn);
|
2016-01-18 19:05:58 +00:00
|
|
|
int tries = 0;
|
2016-01-20 09:27:18 +00:00
|
|
|
usleep(1000 * UID_DELAY);
|
2016-01-18 19:57:49 +00:00
|
|
|
while (uid < 0 && tries++ < UID_MAXTRY) {
|
2016-01-19 20:10:48 +00:00
|
|
|
// Check IPv6 table first
|
|
|
|
if (version == 4) {
|
|
|
|
int8_t saddr128[16];
|
|
|
|
memset(saddr128, 0, 10);
|
|
|
|
saddr128[10] = 0xFF;
|
|
|
|
saddr128[11] = 0xFF;
|
|
|
|
memcpy(saddr128 + 12, saddr, 4);
|
|
|
|
uid = get_uid(protocol, 6, saddr128, sport, tries == UID_MAXTRY);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (uid < 0)
|
2016-01-19 08:49:47 +00:00
|
|
|
uid = get_uid(protocol, version, saddr, sport, tries == UID_MAXTRY);
|
2016-01-18 19:05:58 +00:00
|
|
|
|
|
|
|
// Retry delay
|
2016-01-18 19:57:49 +00:00
|
|
|
if (uid < 0 && tries < UID_MAXTRY) {
|
2016-01-20 09:27:18 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "get uid %s/%u syn %d try %d",
|
|
|
|
dest, dport, syn, tries);
|
|
|
|
usleep(1000 * UID_DELAYTRY);
|
2016-01-18 19:05:58 +00:00
|
|
|
}
|
2016-01-15 18:51:07 +00:00
|
|
|
}
|
2016-01-18 19:05:58 +00:00
|
|
|
|
|
|
|
if (uid < 0)
|
2016-01-19 08:49:47 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "uid not found");
|
2016-01-15 18:51:07 +00:00
|
|
|
}
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG,
|
|
|
|
"Packet v%d %s/%u -> %s/%u proto %d flags %s uid %d",
|
|
|
|
version, source, sport, dest, dport, protocol, flags, uid);
|
|
|
|
|
|
|
|
#ifdef PROFILE
|
|
|
|
gettimeofday(&end, NULL);
|
|
|
|
mselapsed = (end.tv_sec - start.tv_sec) * 1000.0 +
|
|
|
|
(end.tv_usec - start.tv_usec) / 1000.0;
|
|
|
|
if (mselapsed > 1)
|
|
|
|
log_android(ANDROID_LOG_INFO, "handle ip %f", mselapsed);
|
|
|
|
#endif
|
2016-01-15 18:51:07 +00:00
|
|
|
|
2016-01-19 19:58:51 +00:00
|
|
|
// Check if allowed
|
2016-01-19 20:25:01 +00:00
|
|
|
jboolean allowed = !syn;
|
|
|
|
if (syn && args->filter && uid >= 0) {
|
2016-01-19 19:58:51 +00:00
|
|
|
for (int i = 0; i < args->count; i++)
|
|
|
|
if (args->uid[i] == uid) {
|
|
|
|
allowed = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-19 20:16:54 +00:00
|
|
|
// Handle allowed traffic
|
2016-01-19 19:58:51 +00:00
|
|
|
if (allowed) {
|
2016-01-20 08:24:34 +00:00
|
|
|
if (protocol == IPPROTO_UDP)
|
2016-01-20 13:11:04 +00:00
|
|
|
allowed = handle_udp(args, buffer, length, uid);
|
2016-01-20 08:24:34 +00:00
|
|
|
else if (protocol == IPPROTO_TCP)
|
2016-01-19 19:58:51 +00:00
|
|
|
allowed = handle_tcp(args, buffer, length, uid);
|
|
|
|
else
|
|
|
|
allowed = 0;
|
|
|
|
}
|
2016-01-15 18:51:07 +00:00
|
|
|
|
2016-01-19 20:16:54 +00:00
|
|
|
// Log traffic
|
2016-01-19 16:54:07 +00:00
|
|
|
if (args->log) {
|
2016-01-19 21:25:23 +00:00
|
|
|
if (!args->filter || syn || !(protocol == IPPROTO_TCP || protocol == IPPROTO_UDP))
|
2016-01-19 19:58:51 +00:00
|
|
|
log_java(args, version, source, sport, dest, dport, protocol, flags, uid, allowed);
|
2016-01-19 16:54:07 +00:00
|
|
|
}
|
2016-01-15 18:51:07 +00:00
|
|
|
}
|
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
jboolean handle_udp(const struct arguments *args, const uint8_t *buffer, uint16_t length, int uid) {
|
2016-01-20 08:24:34 +00:00
|
|
|
// Check version
|
|
|
|
uint8_t version = (*buffer) >> 4;
|
|
|
|
if (version != 4)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
// Get headers
|
|
|
|
struct iphdr *iphdr = buffer;
|
|
|
|
uint8_t ipoptlen = (iphdr->ihl - 5) * 4;
|
|
|
|
struct udphdr *udphdr = buffer + sizeof(struct iphdr) + ipoptlen;
|
|
|
|
|
|
|
|
// Get data
|
|
|
|
uint16_t dataoff = sizeof(struct iphdr) + ipoptlen + sizeof(struct udphdr);
|
|
|
|
uint16_t datalen = length - dataoff;
|
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
// Search session
|
|
|
|
struct udp_session *last = NULL;
|
|
|
|
struct udp_session *cur = udp_session;
|
|
|
|
while (cur != NULL && !(cur->saddr == iphdr->saddr && cur->source == udphdr->source &&
|
|
|
|
cur->daddr == iphdr->daddr && cur->dest == udphdr->dest)) {
|
|
|
|
last = cur;
|
|
|
|
cur = cur->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create new session if needed
|
|
|
|
int usock = -1;
|
|
|
|
if (cur == NULL) {
|
|
|
|
log_android(ANDROID_LOG_INFO, "UDP new session");
|
|
|
|
|
|
|
|
// Register session
|
|
|
|
struct udp_session *u = malloc(sizeof(struct udp_session));
|
|
|
|
u->time = time(NULL);
|
|
|
|
u->uid = uid;
|
|
|
|
u->saddr = iphdr->saddr;
|
|
|
|
u->source = udphdr->source;
|
|
|
|
u->daddr = iphdr->daddr;
|
|
|
|
u->dest = udphdr->dest;
|
|
|
|
u->next = NULL;
|
|
|
|
|
|
|
|
// Open UDP socket
|
|
|
|
u->socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
|
|
|
if (u->socket < 0) {
|
|
|
|
log_android(ANDROID_LOG_ERROR, "UDP socket error %d: %s", errno, strerror(errno));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
protect_socket(args, u->socket);
|
|
|
|
|
|
|
|
//struct sockaddr_in uaddr;
|
|
|
|
//uaddr.sin_family = AF_INET;
|
|
|
|
//uaddr.sin_addr.s_addr = INADDR_ANY;
|
|
|
|
//uaddr.sin_port = 0;
|
|
|
|
//if (bind(usock, (struct sockaddr *) &uaddr, sizeof(struct sockaddr)) < 0) {
|
|
|
|
// log_android(ANDROID_LOG_ERROR, "UDP bind error %d: %s", errno, strerror(errno));
|
|
|
|
// return 0;
|
|
|
|
//}
|
|
|
|
|
|
|
|
if (last == NULL)
|
|
|
|
udp_session = u;
|
|
|
|
else
|
|
|
|
last->next = u;
|
|
|
|
|
|
|
|
usock = u->socket;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
cur->time = time(NULL);
|
|
|
|
usock = cur->socket;
|
|
|
|
}
|
2016-01-20 08:24:34 +00:00
|
|
|
|
2016-01-20 11:14:15 +00:00
|
|
|
char source[40];
|
2016-01-20 08:24:34 +00:00
|
|
|
char dest[40];
|
2016-01-20 13:11:04 +00:00
|
|
|
inet_ntop(version == 4 ? AF_INET : AF_INET6, &(iphdr->saddr), source, sizeof(source));
|
|
|
|
inet_ntop(version == 4 ? AF_INET : AF_INET6, &(iphdr->daddr), dest, sizeof(dest));
|
2016-01-20 08:24:34 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "UDP forward from tun %s/%u to %s/%u data %d",
|
2016-01-20 11:14:15 +00:00
|
|
|
source, ntohs(udphdr->source), dest, ntohs(udphdr->dest), datalen);
|
2016-01-20 08:24:34 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
struct sockaddr_in server;
|
|
|
|
server.sin_family = (version == 4 ? AF_INET : AF_INET6);
|
|
|
|
server.sin_addr.s_addr = iphdr->daddr;
|
|
|
|
server.sin_port = udphdr->dest;
|
2016-01-20 08:24:34 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
if (sendto(usock, buffer + dataoff, datalen, 0, &server, sizeof(server)) != datalen) {
|
2016-01-20 08:24:34 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "UDP sendto error %s:%s", errno, strerror(errno));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
jboolean handle_tcp(const struct arguments *args, const uint8_t *buffer, uint16_t length, int uid) {
|
2016-01-18 18:37:52 +00:00
|
|
|
#ifdef PROFILE
|
|
|
|
float mselapsed;
|
|
|
|
struct timeval start, end;
|
|
|
|
gettimeofday(&start, NULL);
|
|
|
|
#endif
|
|
|
|
|
2016-01-12 08:45:58 +00:00
|
|
|
// Check version
|
2016-01-14 14:02:32 +00:00
|
|
|
uint8_t version = (*buffer) >> 4;
|
2016-01-12 08:45:58 +00:00
|
|
|
if (version != 4)
|
2016-01-19 19:58:51 +00:00
|
|
|
return 0;
|
2016-01-12 08:45:58 +00:00
|
|
|
|
2016-01-11 22:06:35 +00:00
|
|
|
// Get headers
|
2016-01-12 18:44:56 +00:00
|
|
|
struct iphdr *iphdr = buffer;
|
2016-01-18 20:18:23 +00:00
|
|
|
uint8_t ipoptlen = (iphdr->ihl - 5) * 4;
|
|
|
|
struct tcphdr *tcphdr = buffer + sizeof(struct iphdr) + ipoptlen;
|
|
|
|
uint8_t tcpoptlen = (tcphdr->doff - 5) * 4;
|
|
|
|
if (tcpoptlen) {
|
|
|
|
// TODO handle TCP options
|
2016-01-20 09:27:18 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "optlen %d", tcpoptlen);
|
2016-01-18 20:18:23 +00:00
|
|
|
}
|
2016-01-12 18:44:56 +00:00
|
|
|
|
|
|
|
// Get data
|
2016-01-18 20:18:23 +00:00
|
|
|
uint16_t dataoff = sizeof(struct iphdr) + ipoptlen + sizeof(struct tcphdr) + tcpoptlen;
|
2016-01-12 19:47:01 +00:00
|
|
|
uint16_t datalen = length - dataoff;
|
2016-01-11 22:06:35 +00:00
|
|
|
|
2016-01-16 08:07:04 +00:00
|
|
|
// Search session
|
2016-01-20 11:35:51 +00:00
|
|
|
struct tcp_session *last = NULL;
|
|
|
|
struct tcp_session *cur = tcp_session;
|
2016-01-16 19:58:12 +00:00
|
|
|
while (cur != NULL && !(cur->saddr == iphdr->saddr && cur->source == tcphdr->source &&
|
|
|
|
cur->daddr == iphdr->daddr && cur->dest == tcphdr->dest)) {
|
2016-01-11 22:06:35 +00:00
|
|
|
last = cur;
|
|
|
|
cur = cur->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Log
|
|
|
|
char dest[20];
|
|
|
|
inet_ntop(AF_INET, &(iphdr->daddr), dest, sizeof(dest));
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "Received %s/%u seq %u ack %u window %u data %d",
|
|
|
|
dest, ntohs(tcphdr->dest),
|
|
|
|
ntohl(tcphdr->seq) - (cur == NULL ? 0 : cur->remote_start),
|
|
|
|
ntohl(tcphdr->ack_seq) - (cur == NULL ? 0 : cur->local_start),
|
|
|
|
ntohs(tcphdr->window), datalen);
|
2016-01-11 22:06:35 +00:00
|
|
|
|
|
|
|
if (cur == NULL) {
|
|
|
|
if (tcphdr->syn) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "New session %s/%u uid %d",
|
|
|
|
dest, ntohs(tcphdr->dest), uid);
|
2016-01-11 22:06:35 +00:00
|
|
|
|
2016-01-16 08:07:04 +00:00
|
|
|
// Register session
|
2016-01-20 11:35:51 +00:00
|
|
|
struct tcp_session *syn = malloc(sizeof(struct tcp_session));
|
2016-01-12 08:45:58 +00:00
|
|
|
syn->time = time(NULL);
|
2016-01-15 09:28:31 +00:00
|
|
|
syn->uid = uid;
|
2016-01-14 14:02:32 +00:00
|
|
|
syn->remote_seq = ntohl(tcphdr->seq); // ISN remote
|
2016-01-15 09:08:18 +00:00
|
|
|
syn->local_seq = rand(); // ISN local
|
2016-01-17 05:48:33 +00:00
|
|
|
syn->remote_start = syn->remote_seq;
|
|
|
|
syn->local_start = syn->local_seq;
|
2016-01-11 22:06:35 +00:00
|
|
|
syn->saddr = iphdr->saddr;
|
|
|
|
syn->source = tcphdr->source;
|
|
|
|
syn->daddr = iphdr->daddr;
|
|
|
|
syn->dest = tcphdr->dest;
|
2016-01-16 11:32:55 +00:00
|
|
|
syn->state = TCP_LISTEN;
|
2016-01-11 22:06:35 +00:00
|
|
|
syn->next = NULL;
|
2016-01-14 09:11:38 +00:00
|
|
|
|
2016-01-15 11:13:12 +00:00
|
|
|
// TODO handle SYN data?
|
2016-01-18 14:29:01 +00:00
|
|
|
if (datalen)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "SYN session %s/%u data %u",
|
|
|
|
dest, ntohs(tcphdr->dest), datalen);
|
2016-01-13 09:26:06 +00:00
|
|
|
|
|
|
|
// Open socket
|
2016-01-19 14:18:42 +00:00
|
|
|
syn->socket = open_tcp(syn, args);
|
2016-01-15 07:48:18 +00:00
|
|
|
if (syn->socket < 0) {
|
2016-01-15 20:40:37 +00:00
|
|
|
syn->state = TCP_TIME_WAIT;
|
2016-01-18 14:29:01 +00:00
|
|
|
// Remote might retry
|
2016-01-15 07:48:18 +00:00
|
|
|
free(syn);
|
|
|
|
}
|
2016-01-11 22:06:35 +00:00
|
|
|
else {
|
2016-01-17 16:39:11 +00:00
|
|
|
syn->lport = get_local_port(syn->socket);
|
2016-01-11 22:06:35 +00:00
|
|
|
|
2016-01-15 07:48:18 +00:00
|
|
|
if (last == NULL)
|
2016-01-20 11:35:51 +00:00
|
|
|
tcp_session = syn;
|
2016-01-15 07:48:18 +00:00
|
|
|
else
|
|
|
|
last->next = syn;
|
2016-01-11 22:06:35 +00:00
|
|
|
}
|
|
|
|
}
|
2016-01-15 09:28:31 +00:00
|
|
|
else {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "Unknown session %s/%u uid %d",
|
|
|
|
dest, ntohs(tcphdr->dest), uid);
|
2016-01-18 14:29:01 +00:00
|
|
|
|
2016-01-20 11:35:51 +00:00
|
|
|
struct tcp_session rst;
|
|
|
|
memset(&rst, 0, sizeof(struct tcp_session));
|
2016-01-18 14:29:01 +00:00
|
|
|
rst.remote_seq = ntohl(tcphdr->seq);
|
2016-01-17 09:42:21 +00:00
|
|
|
rst.saddr = iphdr->saddr;
|
|
|
|
rst.source = tcphdr->source;
|
|
|
|
rst.daddr = iphdr->daddr;
|
|
|
|
rst.dest = tcphdr->dest;
|
2016-01-18 14:29:01 +00:00
|
|
|
write_rst(&rst, args->tun);
|
2016-01-19 19:58:51 +00:00
|
|
|
|
|
|
|
return 0;
|
2016-01-15 09:28:31 +00:00
|
|
|
}
|
2016-01-18 18:37:52 +00:00
|
|
|
|
|
|
|
#ifdef PROFILE
|
|
|
|
gettimeofday(&end, NULL);
|
|
|
|
mselapsed = (end.tv_sec - start.tv_sec) * 1000.0 +
|
|
|
|
(end.tv_usec - start.tv_usec) / 1000.0;
|
|
|
|
if (mselapsed > 1)
|
|
|
|
log_android(ANDROID_LOG_INFO, "new session %f", mselapsed);
|
|
|
|
#endif
|
2016-01-11 22:06:35 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-01-18 14:29:01 +00:00
|
|
|
// Session found
|
2016-01-16 11:32:55 +00:00
|
|
|
int oldstate = cur->state;
|
|
|
|
uint32_t oldlocal = cur->local_seq;
|
|
|
|
uint32_t oldremote = cur->remote_seq;
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG,
|
|
|
|
"Session %s/%u lport %u state %s local %u remote %u",
|
|
|
|
dest, ntohs(cur->dest), cur->lport, strstate(cur->state),
|
|
|
|
cur->local_seq - cur->local_start,
|
|
|
|
cur->remote_seq - cur->remote_start);
|
2016-01-12 08:45:58 +00:00
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
cur->time = time(NULL);
|
|
|
|
|
2016-01-17 13:30:21 +00:00
|
|
|
// Do not change order of conditions
|
2016-01-16 13:50:02 +00:00
|
|
|
|
2016-01-17 13:30:21 +00:00
|
|
|
if (tcphdr->rst) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "RST session %s/%u lport %u received",
|
|
|
|
dest, ntohs(cur->dest), cur->lport);
|
2016-01-18 14:29:01 +00:00
|
|
|
cur->state = TCP_TIME_WAIT;
|
2016-01-12 12:15:21 +00:00
|
|
|
}
|
2016-01-14 21:48:05 +00:00
|
|
|
|
2016-01-17 19:40:40 +00:00
|
|
|
else if (tcphdr->syn) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "Repeated SYN session %s/%u lport %u",
|
|
|
|
dest, ntohs(cur->dest), cur->lport);
|
2016-01-18 14:29:01 +00:00
|
|
|
// Note: perfect, ordered packet receive assumed
|
2016-01-17 13:30:21 +00:00
|
|
|
|
2016-01-17 19:40:40 +00:00
|
|
|
} else if (tcphdr->fin /* ACK */) {
|
2016-01-16 11:32:55 +00:00
|
|
|
if (ntohl(tcphdr->ack_seq) == cur->local_seq &&
|
|
|
|
ntohl(tcphdr->seq) == cur->remote_seq) {
|
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
if (datalen)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "FIN session %s/%u lport %u data %u",
|
|
|
|
dest, ntohs(cur->dest), cur->lport, datalen);
|
2016-01-16 11:32:55 +00:00
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
// Forward last data to socket
|
2016-01-17 09:42:21 +00:00
|
|
|
int ok = 1;
|
|
|
|
if (tcphdr->ack && datalen) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "send socket data %u", datalen);
|
2016-01-17 19:40:40 +00:00
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
if (send_socket(cur->socket, buffer + dataoff, datalen) < 0)
|
2016-01-17 09:42:21 +00:00
|
|
|
ok = 0;
|
|
|
|
}
|
2016-01-16 11:32:55 +00:00
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
// Shutdown socket for writing
|
|
|
|
if (shutdown(cur->socket, SHUT_WR)) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "shutdown WR error %d: %s",
|
|
|
|
errno, strerror(errno));
|
2016-01-18 14:29:01 +00:00
|
|
|
ok = 0;
|
|
|
|
// Data might be lost
|
|
|
|
}
|
|
|
|
|
2016-01-17 09:42:21 +00:00
|
|
|
if (ok) {
|
2016-01-18 14:29:01 +00:00
|
|
|
if (write_ack(cur, 1 + datalen, args->tun) >= 0) {
|
2016-01-18 19:28:33 +00:00
|
|
|
cur->remote_seq += (1 + datalen); // FIN + data from tun
|
2016-01-17 15:08:40 +00:00
|
|
|
if (cur->state == TCP_ESTABLISHED /* && !tcphdr->ack */)
|
2016-01-17 09:42:21 +00:00
|
|
|
cur->state = TCP_CLOSE_WAIT;
|
2016-01-17 15:08:40 +00:00
|
|
|
else if (cur->state == TCP_FIN_WAIT1 && tcphdr->ack)
|
|
|
|
cur->state = TCP_TIME_WAIT;
|
|
|
|
else if (cur->state == TCP_FIN_WAIT1 && !tcphdr->ack)
|
|
|
|
cur->state = TCP_CLOSING;
|
|
|
|
else if (cur->state == TCP_FIN_WAIT2 /* && !tcphdr->ack */)
|
2016-01-17 09:42:21 +00:00
|
|
|
cur->state = TCP_TIME_WAIT;
|
|
|
|
else
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR,
|
|
|
|
"Invalid FIN session %s/%u lport %u state %s ACK %d",
|
|
|
|
dest, ntohs(cur->dest), cur->lport,
|
|
|
|
strstate(cur->state), tcphdr->ack);
|
2016-01-16 11:32:55 +00:00
|
|
|
}
|
2016-01-18 19:28:33 +00:00
|
|
|
} else
|
2016-01-18 14:29:01 +00:00
|
|
|
write_rst(cur, args->tun);
|
2016-01-15 20:40:37 +00:00
|
|
|
}
|
2016-01-16 13:50:02 +00:00
|
|
|
else {
|
2016-01-18 14:29:01 +00:00
|
|
|
// Special case or hack if you like
|
|
|
|
|
2016-01-17 15:08:40 +00:00
|
|
|
// TODO proper wrap around
|
|
|
|
if (cur->state == TCP_FIN_WAIT1 &&
|
|
|
|
ntohl(tcphdr->seq) == cur->remote_seq &&
|
|
|
|
ntohl(tcphdr->ack_seq) < cur->local_seq) {
|
|
|
|
int confirm = cur->local_seq - ntohl(tcphdr->ack_seq);
|
2016-01-20 08:24:34 +00:00
|
|
|
log_android(ANDROID_LOG_INFO,
|
|
|
|
"Simultaneous close %s/%u lport %u confirm %d",
|
2016-01-18 18:37:52 +00:00
|
|
|
dest, ntohs(cur->dest), cur->lport, confirm);
|
2016-01-18 14:29:01 +00:00
|
|
|
write_ack(cur, confirm, args->tun);
|
2016-01-17 12:45:34 +00:00
|
|
|
}
|
2016-01-17 15:08:40 +00:00
|
|
|
else
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_WARN,
|
|
|
|
"Invalid FIN session %s/%u lport %u state %s seq %u/%u ack %u/%u",
|
|
|
|
dest, ntohs(cur->dest), cur->lport, strstate(cur->state),
|
|
|
|
ntohl(tcphdr->seq) - cur->remote_start,
|
|
|
|
cur->remote_seq - cur->remote_start,
|
|
|
|
ntohl(tcphdr->ack_seq) - cur->local_start,
|
|
|
|
cur->local_seq - cur->local_start);
|
2016-01-16 13:50:02 +00:00
|
|
|
}
|
2016-01-14 21:48:05 +00:00
|
|
|
}
|
|
|
|
|
2016-01-17 13:30:21 +00:00
|
|
|
else if (tcphdr->ack) {
|
|
|
|
if (((uint32_t) ntohl(tcphdr->seq) + 1) == cur->remote_seq) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "Keep alive session %s/%u lport %u",
|
|
|
|
dest, ntohs(cur->dest), cur->lport);
|
2016-01-17 19:40:40 +00:00
|
|
|
|
2016-01-17 13:30:21 +00:00
|
|
|
} else if (ntohl(tcphdr->ack_seq) == cur->local_seq &&
|
|
|
|
ntohl(tcphdr->seq) == cur->remote_seq) {
|
|
|
|
|
|
|
|
if (cur->state == TCP_SYN_RECV) {
|
|
|
|
// TODO process data?
|
2016-01-17 19:40:40 +00:00
|
|
|
// Remote will retry
|
2016-01-17 13:30:21 +00:00
|
|
|
cur->state = TCP_ESTABLISHED;
|
|
|
|
}
|
|
|
|
else if (cur->state == TCP_ESTABLISHED) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "New ACK session %s/%u lport %u data %u",
|
|
|
|
dest, ntohs(cur->dest), cur->lport, datalen);
|
2016-01-17 19:40:40 +00:00
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
// Forward data to socket
|
2016-01-17 13:30:21 +00:00
|
|
|
if (datalen) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG, "send socket data %u", datalen);
|
|
|
|
if (send_socket(cur->socket, buffer + dataoff, datalen) < 0)
|
2016-01-18 14:29:01 +00:00
|
|
|
write_rst(cur, args->tun);
|
2016-01-18 18:37:52 +00:00
|
|
|
else {
|
2016-01-18 14:29:01 +00:00
|
|
|
if (write_ack(cur, datalen, args->tun) >= 0)
|
|
|
|
cur->remote_seq += datalen;
|
2016-01-17 13:30:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (cur->state == TCP_LAST_ACK) {
|
|
|
|
// socket has been shutdown already
|
2016-01-18 14:29:01 +00:00
|
|
|
cur->state = TCP_TIME_WAIT;
|
2016-01-17 13:30:21 +00:00
|
|
|
}
|
|
|
|
else if (cur->state == TCP_FIN_WAIT1)
|
|
|
|
cur->state = TCP_FIN_WAIT2;
|
|
|
|
else if (cur->state == TCP_CLOSING)
|
|
|
|
cur->state = TCP_TIME_WAIT;
|
|
|
|
else
|
2016-01-20 08:24:34 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR,
|
|
|
|
"Invalid ACK session %s/%u lport %u state %s",
|
2016-01-18 18:37:52 +00:00
|
|
|
dest, ntohs(cur->dest), cur->lport, strstate(cur->state));
|
2016-01-17 13:30:21 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-01-17 15:08:40 +00:00
|
|
|
// TODO proper wrap around
|
|
|
|
if (ntohl(tcphdr->seq) == cur->remote_seq &&
|
2016-01-20 09:07:09 +00:00
|
|
|
ntohl(tcphdr->ack_seq) < cur->local_seq) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO,
|
2016-01-20 09:07:09 +00:00
|
|
|
"Previous ACK session %s/%u lport %u seq %u/%u ack %u/%u data %d",
|
2016-01-18 18:37:52 +00:00
|
|
|
dest, ntohs(cur->dest), cur->lport,
|
|
|
|
ntohl(tcphdr->seq) - cur->remote_start,
|
|
|
|
cur->remote_seq - cur->remote_start,
|
|
|
|
ntohl(tcphdr->ack_seq) - cur->local_start,
|
2016-01-20 09:07:09 +00:00
|
|
|
cur->local_seq - cur->local_start,
|
|
|
|
datalen);
|
|
|
|
|
|
|
|
// Forward data to socket
|
|
|
|
if (datalen) {
|
|
|
|
log_android(ANDROID_LOG_DEBUG, "send socket data %u", datalen);
|
|
|
|
if (send_socket(cur->socket, buffer + dataoff, datalen) < 0)
|
|
|
|
write_rst(cur, args->tun);
|
|
|
|
else {
|
|
|
|
if (write_ack(cur, datalen, args->tun) >= 0)
|
|
|
|
cur->remote_seq += datalen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
log_android(ANDROID_LOG_ERROR,
|
|
|
|
"Invalid ACK session %s/%u lport %u state %s seq %u/%u ack %u/%u data %d",
|
2016-01-18 18:37:52 +00:00
|
|
|
dest, ntohs(cur->dest), cur->lport, strstate(cur->state),
|
|
|
|
ntohl(tcphdr->seq) - cur->remote_start,
|
|
|
|
cur->remote_seq - cur->remote_start,
|
|
|
|
ntohl(tcphdr->ack_seq) - cur->local_start,
|
2016-01-20 09:07:09 +00:00
|
|
|
cur->local_seq - cur->local_start,
|
|
|
|
datalen);
|
|
|
|
//write_ack(cur, 0, args->tun);
|
|
|
|
}
|
2016-01-17 13:30:21 +00:00
|
|
|
}
|
2016-01-17 09:42:21 +00:00
|
|
|
}
|
2016-01-16 11:32:55 +00:00
|
|
|
|
|
|
|
else
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "Unknown packet session %s/%u lport %u",
|
|
|
|
dest, ntohs(cur->dest), cur->lport);
|
2016-01-16 11:32:55 +00:00
|
|
|
|
2016-01-20 08:24:34 +00:00
|
|
|
if (cur->state != oldstate || cur->local_seq != oldlocal ||
|
|
|
|
cur->remote_seq != oldremote)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_INFO,
|
|
|
|
"Session %s/%u lport %u new state %s local %u remote %u",
|
|
|
|
dest, ntohs(cur->dest), cur->lport, strstate(cur->state),
|
|
|
|
cur->local_seq - cur->local_start,
|
|
|
|
cur->remote_seq - cur->remote_start);
|
|
|
|
|
|
|
|
#ifdef PROFILE
|
|
|
|
gettimeofday(&end, NULL);
|
|
|
|
mselapsed = (end.tv_sec - start.tv_sec) * 1000.0 +
|
|
|
|
(end.tv_usec - start.tv_usec) / 1000.0;
|
|
|
|
if (mselapsed > 1)
|
|
|
|
log_android(ANDROID_LOG_INFO, "existing session %f", mselapsed);
|
|
|
|
#endif
|
2016-01-13 09:26:06 +00:00
|
|
|
}
|
2016-01-19 19:58:51 +00:00
|
|
|
|
|
|
|
return 1;
|
2016-01-13 09:26:06 +00:00
|
|
|
}
|
|
|
|
|
2016-01-20 11:35:51 +00:00
|
|
|
int open_tcp(const struct tcp_session *cur, const struct arguments *args) {
|
2016-01-13 09:26:06 +00:00
|
|
|
int sock = -1;
|
|
|
|
|
2016-01-18 14:29:01 +00:00
|
|
|
// Build target address
|
|
|
|
struct sockaddr_in daddr;
|
|
|
|
memset(&daddr, 0, sizeof(struct sockaddr_in));
|
|
|
|
daddr.sin_family = AF_INET;
|
|
|
|
daddr.sin_port = cur->dest;
|
|
|
|
daddr.sin_addr.s_addr = cur->daddr;
|
|
|
|
|
2016-01-13 09:26:06 +00:00
|
|
|
// Get TCP socket
|
2016-01-14 09:11:38 +00:00
|
|
|
// TODO socket options (SO_REUSEADDR, etc)
|
2016-01-13 09:26:06 +00:00
|
|
|
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "socket error %d: %s", errno, strerror(errno));
|
2016-01-13 09:26:06 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Protect
|
2016-01-20 08:24:34 +00:00
|
|
|
if (protect_socket(args, sock) < 0)
|
2016-01-13 09:26:06 +00:00
|
|
|
return -1;
|
2016-01-12 12:15:21 +00:00
|
|
|
|
2016-01-18 20:54:45 +00:00
|
|
|
// Set non blocking
|
2016-01-13 10:11:11 +00:00
|
|
|
uint8_t flags = fcntl(sock, F_GETFL, 0);
|
2016-01-18 20:54:45 +00:00
|
|
|
if (flags < 0 || fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "fcntl socket O_NONBLOCK error %d: %s",
|
|
|
|
errno, strerror(errno));
|
2016-01-13 10:11:11 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-01-13 09:26:06 +00:00
|
|
|
// Initiate connect
|
2016-01-18 14:29:01 +00:00
|
|
|
int err = connect(sock, &daddr, sizeof(struct sockaddr_in));
|
2016-01-13 09:26:06 +00:00
|
|
|
if (err < 0 && errno != EINPROGRESS) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "connect error %d: %s", errno, strerror(errno));
|
2016-01-13 09:26:06 +00:00
|
|
|
return -1;
|
2016-01-11 22:06:35 +00:00
|
|
|
}
|
2016-01-13 09:26:06 +00:00
|
|
|
|
2016-01-13 18:25:15 +00:00
|
|
|
// Set blocking
|
2016-01-14 14:02:32 +00:00
|
|
|
if (fcntl(sock, F_SETFL, flags & ~O_NONBLOCK) < 0) {
|
2016-01-19 08:49:47 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "fcntl socket ~O_NONBLOCK error %d: %s",
|
|
|
|
errno, strerror(errno));
|
2016-01-13 18:25:15 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-01-13 09:26:06 +00:00
|
|
|
return sock;
|
2016-01-11 22:06:35 +00:00
|
|
|
}
|
|
|
|
|
2016-01-17 16:39:11 +00:00
|
|
|
int get_local_port(const int sock) {
|
2016-01-13 09:26:06 +00:00
|
|
|
struct sockaddr_in sin;
|
|
|
|
int len = sizeof(sin);
|
|
|
|
if (getsockname(sock, &sin, &len) < 0) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "getsockname error %d: %s", errno, strerror(errno));
|
2016-01-13 09:26:06 +00:00
|
|
|
return -1;
|
|
|
|
} else
|
|
|
|
return ntohs(sin.sin_port);
|
|
|
|
}
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
ssize_t send_socket(int sock, uint8_t *buffer, uint16_t len) {
|
|
|
|
// TODO non blocking
|
|
|
|
ssize_t res = send(sock, buffer, len, 0);
|
|
|
|
if (res < 0)
|
|
|
|
log_android(ANDROID_LOG_ERROR, "send error %d: %s", errno, strerror(errno));
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2016-01-20 11:35:51 +00:00
|
|
|
int write_syn_ack(struct tcp_session *cur, int tun) {
|
2016-01-20 09:07:09 +00:00
|
|
|
if (write_tcp(cur, NULL, 0, 1, 1, 1, 0, 0, tun) < 0) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "write SYN+ACK error %d: %s",
|
|
|
|
errno, strerror((errno)));
|
2016-01-18 14:29:01 +00:00
|
|
|
cur->state = TCP_TIME_WAIT;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-20 11:35:51 +00:00
|
|
|
int write_ack(struct tcp_session *cur, int bytes, int tun) {
|
2016-01-20 09:07:09 +00:00
|
|
|
if (write_tcp(cur, NULL, 0, bytes, 0, 1, 0, 0, tun) < 0) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "write ACK error %d: %s",
|
|
|
|
errno, strerror((errno)));
|
2016-01-18 14:29:01 +00:00
|
|
|
cur->state = TCP_TIME_WAIT;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-20 11:35:51 +00:00
|
|
|
int write_data(struct tcp_session *cur, const uint8_t *buffer, uint16_t length, int tun) {
|
2016-01-20 09:07:09 +00:00
|
|
|
if (write_tcp(cur, buffer, length, 0, 0, 1, 0, 0, tun) < 0) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "write data ACK lport %u error %d: %s",
|
|
|
|
cur->lport, errno, strerror((errno)));
|
2016-01-18 14:29:01 +00:00
|
|
|
cur->state = TCP_TIME_WAIT;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-01-20 11:35:51 +00:00
|
|
|
int write_fin(struct tcp_session *cur, int tun) {
|
2016-01-20 09:07:09 +00:00
|
|
|
if (write_tcp(cur, NULL, 0, 0, 0, 0, 1, 0, tun) < 0) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR,
|
|
|
|
"write FIN lport %u error %d: %s",
|
|
|
|
cur->lport, errno, strerror((errno)));
|
2016-01-18 14:29:01 +00:00
|
|
|
cur->state = TCP_TIME_WAIT;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-20 11:35:51 +00:00
|
|
|
void write_rst(struct tcp_session *cur, int tun) {
|
2016-01-18 19:05:58 +00:00
|
|
|
log_android(ANDROID_LOG_WARN, "Sending RST");
|
2016-01-20 09:07:09 +00:00
|
|
|
if (write_tcp(cur, NULL, 0, 0, 0, 0, 0, 1, tun) < 0)
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "write RST error %d: %s",
|
|
|
|
errno, strerror((errno)));
|
2016-01-18 14:29:01 +00:00
|
|
|
cur->state = TCP_TIME_WAIT;
|
|
|
|
}
|
2016-01-17 19:40:40 +00:00
|
|
|
|
2016-01-20 13:11:04 +00:00
|
|
|
int write_udp(const struct udp_session *cur, uint8_t *data, uint16_t datalen, int tun) {
|
|
|
|
#ifdef PROFILE
|
|
|
|
float mselapsed;
|
|
|
|
struct timeval start, end;
|
|
|
|
gettimeofday(&start, NULL);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Build packet
|
|
|
|
uint16_t len = sizeof(struct iphdr) + sizeof(struct udphdr) + datalen;
|
|
|
|
u_int8_t *buffer = calloc(len, 1);
|
|
|
|
struct iphdr *ip = buffer;
|
|
|
|
struct udphdr *udp = buffer + sizeof(struct iphdr);
|
|
|
|
if (datalen)
|
|
|
|
memcpy(buffer + sizeof(struct iphdr) + sizeof(struct udphdr), data, datalen);
|
|
|
|
|
|
|
|
// Build IP header
|
|
|
|
ip->version = 4;
|
|
|
|
ip->ihl = sizeof(struct iphdr) >> 2;
|
|
|
|
ip->tot_len = htons(len);
|
|
|
|
ip->ttl = UDP_TTL;
|
|
|
|
ip->protocol = IPPROTO_UDP;
|
|
|
|
ip->saddr = cur->daddr;
|
|
|
|
ip->daddr = cur->saddr;
|
|
|
|
|
|
|
|
// Calculate IP checksum
|
|
|
|
ip->check = calc_checksum(ip, sizeof(struct iphdr));
|
|
|
|
|
|
|
|
// Build TCP header
|
|
|
|
udp->source = cur->dest;
|
|
|
|
udp->dest = cur->source;
|
|
|
|
udp->check = 0;
|
|
|
|
udp->len = htons(sizeof(struct udphdr) + datalen);
|
|
|
|
|
|
|
|
char to[20];
|
|
|
|
inet_ntop(AF_INET, &(ip->daddr), to, sizeof(to));
|
|
|
|
|
|
|
|
// Send packet
|
|
|
|
log_android(ANDROID_LOG_DEBUG,
|
|
|
|
"Sending UDP to tun %s/%u data %u",
|
|
|
|
to, ntohs(udp->dest), datalen);
|
|
|
|
|
|
|
|
// TODO non blocking
|
|
|
|
int res = write(tun, buffer, len);
|
|
|
|
|
|
|
|
#ifdef PROFILE
|
|
|
|
gettimeofday(&end, NULL);
|
|
|
|
mselapsed = (end.tv_sec - start.tv_sec) * 1000.0 +
|
|
|
|
(end.tv_usec - start.tv_usec) / 1000.0;
|
|
|
|
if (mselapsed > 1)
|
|
|
|
log_android(ANDROID_LOG_INFO, "tun UDP write %f", mselapsed);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Write pcap record
|
|
|
|
if (pcap_fn != NULL)
|
|
|
|
write_pcap_rec(buffer, len);
|
|
|
|
|
|
|
|
free(buffer);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-20 11:35:51 +00:00
|
|
|
int write_tcp(const struct tcp_session *cur,
|
2016-01-17 16:39:11 +00:00
|
|
|
uint8_t *data, uint16_t datalen, uint16_t confirm,
|
2016-01-20 09:07:09 +00:00
|
|
|
int syn, int ack, int fin, int rst, int tun) {
|
2016-01-18 18:37:52 +00:00
|
|
|
#ifdef PROFILE
|
|
|
|
float mselapsed;
|
|
|
|
struct timeval start, end;
|
|
|
|
gettimeofday(&start, NULL);
|
|
|
|
#endif
|
|
|
|
|
2016-01-14 14:02:32 +00:00
|
|
|
// Build packet
|
2016-01-15 09:28:31 +00:00
|
|
|
uint16_t len = sizeof(struct iphdr) + sizeof(struct tcphdr) + datalen;
|
2016-01-14 14:02:32 +00:00
|
|
|
u_int8_t *buffer = calloc(len, 1);
|
|
|
|
struct iphdr *ip = buffer;
|
|
|
|
struct tcphdr *tcp = buffer + sizeof(struct iphdr);
|
2016-01-14 18:30:38 +00:00
|
|
|
if (datalen)
|
2016-01-16 14:12:42 +00:00
|
|
|
memcpy(buffer + sizeof(struct iphdr) + sizeof(struct tcphdr), data, datalen);
|
2016-01-14 14:02:32 +00:00
|
|
|
|
|
|
|
// Build IP header
|
|
|
|
ip->version = 4;
|
|
|
|
ip->ihl = sizeof(struct iphdr) >> 2;
|
|
|
|
ip->tot_len = htons(len);
|
2016-01-18 19:57:49 +00:00
|
|
|
ip->ttl = TCP_TTL;
|
2016-01-14 14:02:32 +00:00
|
|
|
ip->protocol = IPPROTO_TCP;
|
|
|
|
ip->saddr = cur->daddr;
|
|
|
|
ip->daddr = cur->saddr;
|
|
|
|
|
|
|
|
// Calculate IP checksum
|
2016-01-18 18:37:52 +00:00
|
|
|
ip->check = calc_checksum(ip, sizeof(struct iphdr));
|
2016-01-14 14:02:32 +00:00
|
|
|
|
|
|
|
// Build TCP header
|
|
|
|
tcp->source = cur->dest;
|
|
|
|
tcp->dest = cur->source;
|
2016-01-17 05:41:32 +00:00
|
|
|
tcp->seq = htonl(cur->local_seq);
|
2016-01-17 09:42:21 +00:00
|
|
|
tcp->ack_seq = htonl((uint32_t) (cur->remote_seq + confirm));
|
2016-01-14 14:02:32 +00:00
|
|
|
tcp->doff = sizeof(struct tcphdr) >> 2;
|
2016-01-15 09:04:44 +00:00
|
|
|
tcp->syn = syn;
|
2016-01-20 09:07:09 +00:00
|
|
|
tcp->ack = ack;
|
2016-01-14 21:48:05 +00:00
|
|
|
tcp->fin = fin;
|
2016-01-15 09:04:44 +00:00
|
|
|
tcp->rst = rst;
|
2016-01-18 19:57:49 +00:00
|
|
|
tcp->window = htons(TCP_WINDOW);
|
2016-01-14 14:02:32 +00:00
|
|
|
|
2016-01-17 09:42:21 +00:00
|
|
|
if (!tcp->ack)
|
|
|
|
tcp->ack_seq = 0;
|
|
|
|
|
2016-01-14 14:02:32 +00:00
|
|
|
// Calculate TCP checksum
|
2016-01-16 14:12:42 +00:00
|
|
|
// TODO optimize memory usage
|
2016-01-14 18:30:38 +00:00
|
|
|
uint16_t clen = sizeof(struct ippseudo) + sizeof(struct tcphdr) + datalen;
|
2016-01-14 14:02:32 +00:00
|
|
|
uint8_t csum[clen];
|
|
|
|
|
|
|
|
// Build pseudo header
|
|
|
|
struct ippseudo *pseudo = csum;
|
|
|
|
pseudo->ippseudo_src.s_addr = ip->saddr;
|
|
|
|
pseudo->ippseudo_dst.s_addr = ip->daddr;
|
|
|
|
pseudo->ippseudo_pad = 0;
|
|
|
|
pseudo->ippseudo_p = ip->protocol;
|
2016-01-15 09:28:31 +00:00
|
|
|
pseudo->ippseudo_len = htons(sizeof(struct tcphdr) + datalen);
|
2016-01-14 14:02:32 +00:00
|
|
|
|
2016-01-14 18:30:38 +00:00
|
|
|
// Copy TCP header + data
|
2016-01-14 14:02:32 +00:00
|
|
|
memcpy(csum + sizeof(struct ippseudo), tcp, sizeof(struct tcphdr));
|
2016-01-14 18:30:38 +00:00
|
|
|
if (datalen)
|
2016-01-16 14:12:42 +00:00
|
|
|
memcpy(csum + sizeof(struct ippseudo) + sizeof(struct tcphdr), data, datalen);
|
2016-01-14 14:02:32 +00:00
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
tcp->check = calc_checksum(csum, clen);
|
2016-01-14 14:02:32 +00:00
|
|
|
|
|
|
|
char to[20];
|
|
|
|
inet_ntop(AF_INET, &(ip->daddr), to, sizeof(to));
|
|
|
|
|
|
|
|
// Send packet
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_DEBUG,
|
|
|
|
"Sending%s%s%s%s to tun %s/%u seq %u ack %u data %u confirm %u",
|
|
|
|
(tcp->syn ? " SYN" : ""),
|
|
|
|
(tcp->ack ? " ACK" : ""),
|
|
|
|
(tcp->fin ? " FIN" : ""),
|
|
|
|
(tcp->rst ? " RST" : ""),
|
|
|
|
to, ntohs(tcp->dest),
|
|
|
|
ntohl(tcp->seq) - cur->local_start,
|
|
|
|
ntohl(tcp->ack_seq) - cur->remote_start,
|
|
|
|
datalen, confirm);
|
2016-01-18 20:18:23 +00:00
|
|
|
|
|
|
|
// TODO non blocking
|
2016-01-14 14:02:32 +00:00
|
|
|
int res = write(tun, buffer, len);
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
#ifdef PROFILE
|
|
|
|
gettimeofday(&end, NULL);
|
|
|
|
mselapsed = (end.tv_sec - start.tv_sec) * 1000.0 +
|
|
|
|
(end.tv_usec - start.tv_usec) / 1000.0;
|
|
|
|
if (mselapsed > 1)
|
2016-01-20 13:11:04 +00:00
|
|
|
log_android(ANDROID_LOG_INFO, "tun TCP write %f", mselapsed);
|
2016-01-18 18:37:52 +00:00
|
|
|
#endif
|
|
|
|
|
2016-01-17 19:40:40 +00:00
|
|
|
// Write pcap record
|
2016-01-19 16:54:07 +00:00
|
|
|
if (pcap_fn != NULL)
|
2016-01-18 20:37:51 +00:00
|
|
|
write_pcap_rec(buffer, len);
|
2016-01-17 09:42:21 +00:00
|
|
|
|
2016-01-14 14:02:32 +00:00
|
|
|
free(buffer);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2016-01-19 08:49:47 +00:00
|
|
|
uint8_t char2nible(const char c) {
|
|
|
|
if (c >= '0' && c <= '9') return (c - '0');
|
|
|
|
if (c >= 'a' && c <= 'f') return (c - 'a') + 10;
|
|
|
|
if (c >= 'A' && c <= 'F') return (c - 'A') + 10;
|
|
|
|
return 255;
|
|
|
|
}
|
|
|
|
|
|
|
|
void hex2bytes(const char *hex, uint8_t *buffer) {
|
|
|
|
int len = strlen(hex);
|
|
|
|
for (int i = 0; i < len; i += 2)
|
|
|
|
buffer[i / 2] = (char2nible(hex[i]) << 4) | char2nible(hex[i + 1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
jint get_uid(const int protocol, const int version,
|
|
|
|
const void *saddr, const uint16_t sport, int dump) {
|
2016-01-10 07:14:47 +00:00
|
|
|
char line[250];
|
2016-01-19 08:49:47 +00:00
|
|
|
char hex[16 * 2 + 1];
|
2016-01-10 07:14:47 +00:00
|
|
|
int fields;
|
2016-01-19 08:49:47 +00:00
|
|
|
uint8_t addr4[4];
|
|
|
|
uint8_t addr6[16];
|
2016-01-12 19:47:01 +00:00
|
|
|
uint16_t port;
|
|
|
|
jint uid = -1;
|
2016-01-10 07:14:47 +00:00
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
#ifdef PROFILE
|
|
|
|
float mselapsed;
|
|
|
|
struct timeval start, end;
|
|
|
|
gettimeofday(&start, NULL);
|
|
|
|
#endif
|
|
|
|
|
2016-01-10 07:14:47 +00:00
|
|
|
// Get proc file name
|
|
|
|
char *fn = NULL;
|
|
|
|
if (protocol == IPPROTO_TCP)
|
|
|
|
fn = (version == 4 ? "/proc/net/tcp" : "/proc/net/tcp6");
|
|
|
|
else if (protocol == IPPROTO_UDP)
|
|
|
|
fn = (version == 4 ? "/proc/net/udp" : "/proc/net/udp6");
|
|
|
|
else
|
2016-01-15 11:13:12 +00:00
|
|
|
return uid;
|
2016-01-10 07:14:47 +00:00
|
|
|
|
2016-01-19 08:49:47 +00:00
|
|
|
if (dump) {
|
|
|
|
char source[40];
|
|
|
|
inet_ntop(version == 4 ? AF_INET : AF_INET6, saddr, source, sizeof(source));
|
|
|
|
log_android(ANDROID_LOG_INFO, "Searching %s/%u in %s", source, sport, fn);
|
|
|
|
}
|
|
|
|
|
2016-01-10 07:14:47 +00:00
|
|
|
// Open proc file
|
|
|
|
FILE *fd = fopen(fn, "r");
|
|
|
|
if (fd == NULL) {
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "fopen %s error %d: %s", fn, errno, strerror(errno));
|
2016-01-15 11:13:12 +00:00
|
|
|
return uid;
|
2016-01-10 07:14:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Scan proc file
|
2016-01-15 11:13:12 +00:00
|
|
|
jint u;
|
2016-01-10 07:14:47 +00:00
|
|
|
int i = 0;
|
|
|
|
while (fgets(line, sizeof(line), fd) != NULL) {
|
|
|
|
if (i++) {
|
|
|
|
if (version == 4)
|
2016-01-18 18:37:52 +00:00
|
|
|
fields = sscanf(
|
|
|
|
line,
|
2016-01-19 08:49:47 +00:00
|
|
|
"%*d: %8s:%X %*X:%*X %*X %*lX:%*lX %*X:%*X %*X %d %*d %*ld",
|
|
|
|
hex, &port, &u);
|
2016-01-10 07:14:47 +00:00
|
|
|
else
|
2016-01-18 18:37:52 +00:00
|
|
|
fields = sscanf(
|
|
|
|
line,
|
2016-01-19 08:49:47 +00:00
|
|
|
"%*d: %32s:%X %*X:%*X %*X %*lX:%*lX %*X:%*X %*X %d %*d %*ld",
|
|
|
|
hex, &port, &u);
|
|
|
|
if (fields == 3) {
|
|
|
|
hex2bytes(hex, version == 4 ? addr4 : addr6);
|
|
|
|
if (version == 4)
|
|
|
|
((uint32_t *) addr4)[0] = htonl(((uint32_t *) addr4)[0]);
|
|
|
|
for (int w = 0; w < 4; w++)
|
|
|
|
((uint32_t *) addr6)[w] = htonl(((uint32_t *) addr6)[w]);
|
|
|
|
|
|
|
|
if (dump) {
|
|
|
|
char source[40];
|
|
|
|
inet_ntop(version == 4 ? AF_INET : AF_INET6,
|
|
|
|
version == 4 ? addr4 : addr6,
|
|
|
|
source, sizeof(source));
|
|
|
|
log_android(ANDROID_LOG_INFO, "%s/%u %d", source, sport, u);
|
|
|
|
}
|
2016-01-15 11:13:12 +00:00
|
|
|
|
|
|
|
if (port == sport) {
|
2016-01-20 08:24:34 +00:00
|
|
|
if (memcmp(version == 4 ? addr4 : addr6, saddr, version == 4 ? 4 : 16) ==
|
|
|
|
0) {
|
2016-01-19 08:49:47 +00:00
|
|
|
uid = u;
|
|
|
|
break;
|
2016-01-15 11:13:12 +00:00
|
|
|
}
|
2016-01-10 11:51:02 +00:00
|
|
|
}
|
2016-01-15 11:13:12 +00:00
|
|
|
} else
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "Invalid field #%d: %s", fields, line);
|
2016-01-09 20:17:42 +00:00
|
|
|
}
|
|
|
|
}
|
2016-01-10 07:14:47 +00:00
|
|
|
|
2016-01-15 09:28:31 +00:00
|
|
|
if (fclose(fd))
|
2016-01-18 18:37:52 +00:00
|
|
|
log_android(ANDROID_LOG_ERROR, "fclose %s error %d: %s", fn, errno, strerror(errno));
|
|
|
|
|
|
|
|
#ifdef PROFILE
|
|
|
|
gettimeofday(&end, NULL);
|
|
|
|
mselapsed = (end.tv_sec - start.tv_sec) * 1000.0 +
|
|
|
|
(end.tv_usec - start.tv_usec) / 1000.0;
|
|
|
|
if (mselapsed > 1)
|
|
|
|
log_android(ANDROID_LOG_INFO, "get uid ip %f", mselapsed);
|
|
|
|
#endif
|
2016-01-10 07:14:47 +00:00
|
|
|
|
2016-01-15 11:13:12 +00:00
|
|
|
return uid;
|
2016-01-12 12:15:21 +00:00
|
|
|
}
|
|
|
|
|
2016-01-20 08:24:34 +00:00
|
|
|
int protect_socket(struct arguments *args, int socket) {
|
|
|
|
JNIEnv *env = args->env;
|
|
|
|
jobject instance = args->instance;
|
|
|
|
|
|
|
|
jclass cls = (*env)->GetObjectClass(env, instance);
|
|
|
|
jmethodID mid = (*env)->GetMethodID(env, cls, "protect", "(I)Z");
|
|
|
|
if (mid == 0) {
|
|
|
|
log_android(ANDROID_LOG_ERROR, "protect method not found");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
jboolean isProtected = (*env)->CallBooleanMethod(env, instance, mid, socket);
|
|
|
|
if (!isProtected) {
|
|
|
|
log_android(ANDROID_LOG_ERROR, "protect failed");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
jthrowable ex = (*env)->ExceptionOccurred(env);
|
|
|
|
if (ex) {
|
|
|
|
log_android(ANDROID_LOG_ERROR, "protect exception");
|
|
|
|
(*env)->ExceptionDescribe(env);
|
|
|
|
(*env)->ExceptionClear(env);
|
|
|
|
(*env)->DeleteLocalRef(env, ex);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
uint16_t calc_checksum(uint8_t *buffer, uint16_t length) {
|
2016-01-15 11:57:32 +00:00
|
|
|
register uint32_t sum = 0;
|
|
|
|
register uint16_t *buf = buffer;
|
|
|
|
register int len = length;
|
2016-01-12 12:15:21 +00:00
|
|
|
|
2016-01-15 11:57:32 +00:00
|
|
|
while (len > 1) {
|
|
|
|
sum += *buf++;
|
|
|
|
len -= 2;
|
2016-01-12 12:15:21 +00:00
|
|
|
}
|
|
|
|
|
2016-01-15 11:57:32 +00:00
|
|
|
if (len > 0)
|
|
|
|
sum += *((uint8_t *) buf);
|
|
|
|
|
|
|
|
while (sum >> 16)
|
|
|
|
sum = (sum & 0xFFFF) + (sum >> 16);
|
|
|
|
|
|
|
|
return (uint16_t) (~sum);
|
2016-01-12 12:15:21 +00:00
|
|
|
}
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
void log_android(int prio, const char *fmt, ...) {
|
2016-01-17 15:08:40 +00:00
|
|
|
if (prio >= loglevel) {
|
|
|
|
char line[1024];
|
2016-01-17 13:20:07 +00:00
|
|
|
va_list argptr;
|
|
|
|
va_start(argptr, fmt);
|
2016-01-17 15:08:40 +00:00
|
|
|
vsprintf(line, fmt, argptr);
|
|
|
|
__android_log_print(prio, TAG, line);
|
2016-01-17 13:20:07 +00:00
|
|
|
va_end(argptr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-18 18:37:52 +00:00
|
|
|
void log_java(
|
2016-01-19 20:16:54 +00:00
|
|
|
const struct arguments *args, jint version,
|
|
|
|
const char *source, jint sport,
|
|
|
|
const char *dest, jint dport,
|
|
|
|
jint protocol, const char *flags,
|
2016-01-18 18:37:52 +00:00
|
|
|
jint uid, jboolean allowed) {
|
|
|
|
#ifdef PROFILE
|
|
|
|
float mselapsed;
|
|
|
|
struct timeval start, end;
|
|
|
|
gettimeofday(&start, NULL);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
JNIEnv *env = args->env;
|
|
|
|
jobject instance = args->instance;
|
|
|
|
jclass cls = (*env)->GetObjectClass(env, instance);
|
|
|
|
jmethodID mid = (*env)->GetMethodID(
|
|
|
|
env, cls, "logPacket",
|
|
|
|
"(ILjava/lang/String;ILjava/lang/String;IILjava/lang/String;IZ)V");
|
|
|
|
if (mid == 0)
|
|
|
|
log_android(ANDROID_LOG_ERROR, "logPacket not found");
|
|
|
|
else {
|
|
|
|
jstring jsource = (*env)->NewStringUTF(env, source);
|
|
|
|
jstring jdest = (*env)->NewStringUTF(env, dest);
|
|
|
|
jstring jflags = (*env)->NewStringUTF(env, flags);
|
|
|
|
(*env)->CallVoidMethod(env, instance, mid,
|
|
|
|
version,
|
|
|
|
jsource, sport,
|
|
|
|
jdest, dport,
|
|
|
|
protocol, jflags,
|
|
|
|
uid, allowed);
|
|
|
|
(*env)->DeleteLocalRef(env, jsource);
|
|
|
|
(*env)->DeleteLocalRef(env, jdest);
|
|
|
|
(*env)->DeleteLocalRef(env, jflags);
|
|
|
|
|
|
|
|
jthrowable ex = (*env)->ExceptionOccurred(env);
|
|
|
|
if (ex) {
|
|
|
|
(*env)->ExceptionDescribe(env);
|
|
|
|
(*env)->ExceptionClear(env);
|
|
|
|
(*env)->DeleteLocalRef(env, ex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
(*env)->DeleteLocalRef(env, cls);
|
|
|
|
|
|
|
|
#ifdef PROFILE
|
|
|
|
gettimeofday(&end, NULL);
|
|
|
|
mselapsed = (end.tv_sec - start.tv_sec) * 1000.0 +
|
|
|
|
(end.tv_usec - start.tv_usec) / 1000.0;
|
|
|
|
if (mselapsed > 1)
|
|
|
|
log_android(ANDROID_LOG_INFO, "log java %f", mselapsed);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void write_pcap(const void *ptr, size_t len) {
|
|
|
|
#ifdef PROFILE
|
|
|
|
float mselapsed;
|
|
|
|
struct timeval start, end;
|
|
|
|
gettimeofday(&start, NULL);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
FILE *fd = fopen(pcap_fn, "ab");
|
|
|
|
if (fd == NULL)
|
|
|
|
log_android(ANDROID_LOG_ERROR, "fopen %s error %d: %s",
|
|
|
|
pcap_fn, errno, strerror(errno));
|
|
|
|
else {
|
|
|
|
if (fwrite(ptr, len, 1, fd) < 1)
|
|
|
|
log_android(ANDROID_LOG_ERROR, "fwrite %s error %d: %s",
|
|
|
|
pcap_fn, errno, strerror(errno));
|
|
|
|
else
|
|
|
|
log_android(ANDROID_LOG_DEBUG, "PCAP write %d", len);
|
|
|
|
|
|
|
|
if (fclose(fd))
|
|
|
|
log_android(ANDROID_LOG_ERROR, "fclose %s error %d: %s",
|
|
|
|
pcap_fn, errno, strerror(errno));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef PROFILE
|
|
|
|
gettimeofday(&end, NULL);
|
|
|
|
mselapsed = (end.tv_sec - start.tv_sec) * 1000.0 +
|
|
|
|
(end.tv_usec - start.tv_usec) / 1000.0;
|
|
|
|
if (mselapsed > 1)
|
|
|
|
log_android(ANDROID_LOG_INFO, "pcap write %f", mselapsed);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-01-18 20:37:51 +00:00
|
|
|
void write_pcap_hdr() {
|
|
|
|
struct pcap_hdr_s pcap_hdr;
|
|
|
|
pcap_hdr.magic_number = 0xa1b2c3d4;
|
|
|
|
pcap_hdr.version_major = 2;
|
|
|
|
pcap_hdr.version_minor = 4;
|
|
|
|
pcap_hdr.thiszone = 0;
|
|
|
|
pcap_hdr.sigfigs = 0;
|
|
|
|
pcap_hdr.snaplen = MAX_PCAP;
|
|
|
|
pcap_hdr.network = LINKTYPE_RAW;
|
|
|
|
write_pcap(&pcap_hdr, sizeof(struct pcap_hdr_s));
|
|
|
|
}
|
|
|
|
|
|
|
|
void write_pcap_rec(const uint8_t *buffer, uint16_t length) {
|
|
|
|
struct timespec ts;
|
|
|
|
if (clock_gettime(CLOCK_REALTIME, &ts))
|
|
|
|
log_android(ANDROID_LOG_ERROR, "clock_gettime error %d: %s", errno, strerror(errno));
|
|
|
|
|
|
|
|
// TODO use stack
|
|
|
|
int plen = (length < MAX_PCAP ? length : MAX_PCAP);
|
|
|
|
struct pcaprec_hdr_s *pcap_rec = malloc(sizeof(struct pcaprec_hdr_s) + plen);
|
|
|
|
|
|
|
|
pcap_rec->ts_sec = ts.tv_sec;
|
|
|
|
pcap_rec->ts_usec = ts.tv_nsec / 1000;
|
|
|
|
pcap_rec->incl_len = plen;
|
|
|
|
pcap_rec->orig_len = length;
|
|
|
|
memcpy(((uint8_t *) pcap_rec) + sizeof(struct pcaprec_hdr_s), buffer, plen);
|
|
|
|
|
|
|
|
write_pcap(pcap_rec, sizeof(struct pcaprec_hdr_s) + plen);
|
|
|
|
|
|
|
|
free(pcap_rec);
|
|
|
|
}
|
|
|
|
|
2016-01-16 11:32:55 +00:00
|
|
|
const char *strstate(const int state) {
|
|
|
|
char buf[20];
|
|
|
|
switch (state) {
|
|
|
|
case TCP_ESTABLISHED:
|
2016-01-18 19:57:49 +00:00
|
|
|
return "ESTABLISHED";
|
2016-01-16 11:32:55 +00:00
|
|
|
case TCP_SYN_SENT:
|
2016-01-18 19:57:49 +00:00
|
|
|
return "SYN_SENT";
|
2016-01-16 11:32:55 +00:00
|
|
|
case TCP_SYN_RECV:
|
2016-01-18 19:57:49 +00:00
|
|
|
return "SYN_RECV";
|
2016-01-16 11:32:55 +00:00
|
|
|
case TCP_FIN_WAIT1:
|
2016-01-18 19:57:49 +00:00
|
|
|
return "FIN_WAIT1";
|
2016-01-16 11:32:55 +00:00
|
|
|
case TCP_FIN_WAIT2:
|
2016-01-18 19:57:49 +00:00
|
|
|
return "FIN_WAIT2";
|
2016-01-16 11:32:55 +00:00
|
|
|
case TCP_TIME_WAIT:
|
2016-01-18 19:57:49 +00:00
|
|
|
return "TIME_WAIT";
|
2016-01-16 11:32:55 +00:00
|
|
|
case TCP_CLOSE:
|
2016-01-18 19:57:49 +00:00
|
|
|
return "CLOSE";
|
2016-01-16 11:32:55 +00:00
|
|
|
case TCP_CLOSE_WAIT:
|
2016-01-18 19:57:49 +00:00
|
|
|
return "CLOSE_WAIT";
|
2016-01-16 11:32:55 +00:00
|
|
|
case TCP_LAST_ACK:
|
2016-01-18 19:57:49 +00:00
|
|
|
return "LAST_ACK";
|
2016-01-16 11:32:55 +00:00
|
|
|
case TCP_LISTEN:
|
2016-01-18 19:57:49 +00:00
|
|
|
return "LISTEN";
|
2016-01-16 11:32:55 +00:00
|
|
|
case TCP_CLOSING:
|
2016-01-18 19:57:49 +00:00
|
|
|
return "CLOSING";
|
2016-01-16 11:32:55 +00:00
|
|
|
default:
|
2016-01-16 13:50:02 +00:00
|
|
|
sprintf(buf, "TCP_%d", state);
|
2016-01-16 11:32:55 +00:00
|
|
|
return buf;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-12 20:15:25 +00:00
|
|
|
char *hex(const u_int8_t *data, const u_int16_t len) {
|
|
|
|
char hex_str[] = "0123456789ABCDEF";
|
2016-01-12 12:15:21 +00:00
|
|
|
|
2016-01-15 11:13:12 +00:00
|
|
|
char *hexout;
|
|
|
|
hexout = (char *) malloc(len * 3 + 1); // TODO free
|
2016-01-12 12:15:21 +00:00
|
|
|
|
|
|
|
for (size_t i = 0; i < len; i++) {
|
2016-01-13 19:17:21 +00:00
|
|
|
hexout[i * 3 + 0] = hex_str[(data[i] >> 4) & 0x0F];
|
|
|
|
hexout[i * 3 + 1] = hex_str[(data[i]) & 0x0F];
|
|
|
|
hexout[i * 3 + 2] = ' ';
|
2016-01-12 12:15:21 +00:00
|
|
|
}
|
2016-01-13 19:17:21 +00:00
|
|
|
return hexout;
|
2016-01-12 16:19:27 +00:00
|
|
|
}
|