src/frontends/android/jni/libandroidbridge/charonservice.c

   1 /*
   2  * Copyright (C) 2012 Giuliano Grassi
   3  * Copyright (C) 2012 Ralf Sager
   4  * Copyright (C) 2012 Tobias Brunner
   5  * Hochschule fuer Technik Rapperswil
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2 of the License, or (at your
  10  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15  * for more details.
  16  */
  17
  18 #include <signal.h>
  19 #include <string.h>
  20 #include <android/log.h>
  21
  22 #include "charonservice.h"
  23 #include "android_jni.h"
  24 #include "kernel/android_ipsec.h"
  25 #include "kernel/android_net.h"
  26
  27 #include <daemon.h>
  28 #include <hydra.h>
  29 #include <ipsec.h>
  30 #include <library.h>
  31 #include <threading/thread.h>
  32
  33 #define ANDROID_DEBUG_LEVEL 1
  34
  35 typedef struct private_charonservice_t private_charonservice_t;
  36
  37 /**
  38  * private data of charonservice
  39  */
  40 struct private_charonservice_t {
  41
  42         /**
  43          * public interface
  44          */
  45         charonservice_t public;
  46
  47         /**
  48          * CharonVpnService reference
  49          */
  50         jobject vpn_service;
  51 };
  52
  53 /**
  54  * Single instance of charonservice_t.
  55  */
  56 charonservice_t *charonservice;
  57
  58 /**
  59  * hook in library for debugging messages
  60  */
  61 extern void (*dbg)(debug_t group, level_t level, char *fmt, ...);
  62
  63 /**
  64  * Logging hook for library logs, using android specific logging
  65  */
  66 static void dbg_android(debug_t group, level_t level, char *fmt, ...)
  67 {
  68         va_list args;
  69
  70         if (level <= ANDROID_DEBUG_LEVEL)
  71         {
  72                 char sgroup[16], buffer[8192];
  73                 char *current = buffer, *next;
  74
  75                 snprintf(sgroup, sizeof(sgroup), "%N", debug_names, group);
  76                 va_start(args, fmt);
  77                 vsnprintf(buffer, sizeof(buffer), fmt, args);
  78                 va_end(args);
  79                 while (current)
  80                 {       /* log each line separately */
  81                         next = strchr(current, '\n');
  82                         if (next)
  83                         {
  84                                 *(next++) = '\0';
  85                         }
  86                         __android_log_print(ANDROID_LOG_INFO, "charon", "00[%s] %s\n",
  87                                                                 sgroup, current);
  88                         current = next;
  89                 }
  90         }
  91 }
  92
  93 METHOD(charonservice_t, update_status, bool,
  94         private_charonservice_t *this, android_vpn_state_t code)
  95 {
  96         JNIEnv *env;
  97         jmethodID method_id;
  98         bool success = FALSE;
  99
 100         androidjni_attach_thread(&env);
 101
 102         method_id = (*env)->GetMethodID(env, android_charonvpnservice_class,
 103                                                                         "updateStatus", "(I)V");
 104         if (!method_id)
 105         {
 106                 goto failed;
 107         }
 108         (*env)->CallVoidMethod(env, this->vpn_service, method_id, (jint)code);
 109         success = !androidjni_exception_occurred(env);
 110
 111 failed:
 112         androidjni_exception_occurred(env);
 113         androidjni_detach_thread();
 114         return success;
 115 }
 116
 117 METHOD(charonservice_t, bypass_socket, bool,
 118         private_charonservice_t *this, int fd, int family)
 119 {
 120         JNIEnv *env;
 121         jmethodID method_id;
 122
 123         androidjni_attach_thread(&env);
 124
 125         method_id = (*env)->GetMethodID(env, android_charonvpnservice_class,
 126                                                                         "protect", "(I)Z");
 127         if (!method_id)
 128         {
 129                 goto failed;
 130         }
 131         if (!(*env)->CallBooleanMethod(env, this->vpn_service, method_id, fd))
 132         {
 133                 DBG1(DBG_CFG, "VpnService.protect() failed");
 134                 goto failed;
 135         }
 136         androidjni_detach_thread();
 137         return TRUE;
 138
 139 failed:
 140         androidjni_exception_occurred(env);
 141         androidjni_detach_thread();
 142         return FALSE;
 143 }
 144
 145 /**
 146  * Initialize the charonservice object
 147  */
 148 static void charonservice_init(JNIEnv *env, jobject service)
 149 {
 150         private_charonservice_t *this;
 151         static plugin_feature_t features[] = {
 152                 PLUGIN_CALLBACK(kernel_net_register, kernel_android_net_create),
 153                         PLUGIN_PROVIDE(CUSTOM, "kernel-net"),
 154                 PLUGIN_CALLBACK(kernel_ipsec_register, kernel_android_ipsec_create),
 155                         PLUGIN_PROVIDE(CUSTOM, "kernel-ipsec"),
 156         };
 157
 158         INIT(this,
 159                 .public = {
 160                         .update_status = _update_status,
 161                         .bypass_socket = _bypass_socket,
 162                 },
 163                 .vpn_service = (*env)->NewGlobalRef(env, service),
 164         );
 165         charonservice = &this->public;
 166
 167         lib->plugins->add_static_features(lib->plugins, "androidbridge", features,
 168                                                                           countof(features), TRUE);
 169
 170         lib->settings->set_int(lib->settings,
 171                                         "charon.plugins.android_log.loglevel", ANDROID_DEBUG_LEVEL);
 172 }
 173
 174 /**
 175  * Deinitialize the charonservice object
 176  */
 177 static void charonservice_deinit(JNIEnv *env)
 178 {
 179         private_charonservice_t *this = (private_charonservice_t*)charonservice;
 180
 181         (*env)->DeleteGlobalRef(env, this->vpn_service);
 182         free(this);
 183         charonservice = NULL;
 184 }
 185
 186 /**
 187  * Handle SIGSEGV/SIGILL signals raised by threads
 188  */
 189 static void segv_handler(int signal)
 190 {
 191         dbg_android(DBG_DMN, 1, "thread %u received %d", thread_current_id(),
 192                                 signal);
 193         exit(1);
 194 }
 195
 196 /**
 197  * Initialize charon and the libraries via JNI
 198  */
 199 JNI_METHOD(CharonVpnService, initializeCharon, void)
 200 {
 201         struct sigaction action;
 202
 203         /* logging for library during initialization, as we have no bus yet */
 204         dbg = dbg_android;
 205
 206         /* initialize library */
 207         if (!library_init(NULL))
 208         {
 209                 library_deinit();
 210                 return;
 211         }
 212
 213         if (!libhydra_init("charon"))
 214         {
 215                 libhydra_deinit();
 216                 library_deinit();
 217                 return;
 218         }
 219
 220         if (!libipsec_init())
 221         {
 222                 libipsec_deinit();
 223                 libhydra_deinit();
 224                 library_deinit();
 225                 return;
 226         }
 227
 228         charonservice_init(env, this);
 229
 230         if (!libcharon_init("charon") ||
 231                 !charon->initialize(charon, PLUGINS))
 232         {
 233                 libcharon_deinit();
 234                 charonservice_deinit(env);
 235                 libipsec_deinit();
 236                 libhydra_deinit();
 237                 library_deinit();
 238                 return;
 239         }
 240
 241         /* add handler for SEGV and ILL etc. */
 242         action.sa_handler = segv_handler;
 243         action.sa_flags = 0;
 244         sigemptyset(&action.sa_mask);
 245         sigaction(SIGSEGV, &action, NULL);
 246         sigaction(SIGILL, &action, NULL);
 247         sigaction(SIGBUS, &action, NULL);
 248         action.sa_handler = SIG_IGN;
 249         sigaction(SIGPIPE, &action, NULL);
 250
 251         /* start daemon (i.e. the threads in the thread-pool) */
 252         charon->start(charon);
 253 }
 254
 255 /**
 256  * Deinitialize charon and all libraries
 257  */
 258 JNI_METHOD(CharonVpnService, deinitializeCharon, void)
 259 {
 260         libcharon_deinit();
 261         charonservice_deinit(env);
 262         libipsec_deinit();
 263         libhydra_deinit();
 264         library_deinit();
 265 }
 266