src/vpnsvc.c

   1 /*
   2  * Network Configuration - VPN Service Module
   3  *
   4  * Copyright (c) 2015 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <gio/gunixfdlist.h>
  24
  25 #include "vpnsvc.h"
  26 #include "vpnsvc-internal.h"
  27 #include "netdbus.h"
  28 #include "log.h"
  29
  30 static Vpnsvc *vpnsvc = NULL;
  31
  32 /*********************
  33  * Handler Functions *
  34  ********************/
  35 gboolean handle_vpn_init(Vpnsvc *object,
  36                                                                 GDBusMethodInvocation *invocation,
  37                                                                 const gchar *arg_iface_name,
  38                                                                 guint arg_iface_name_len)
  39 {
  40         DBG("handle_vpn_init");
  41
  42         int result = VPNSVC_ERROR_NONE;
  43
  44         vpnsvc_tun_s handle_s;
  45         GDBusMessage *msg;
  46         GUnixFDList *fd_list;
  47         int fd_list_length;
  48         const int *fds;
  49
  50         DBG("vpn_init, %s, %u\n", arg_iface_name, arg_iface_name_len);
  51
  52         msg = g_dbus_method_invocation_get_message(invocation);
  53         fd_list = g_dbus_message_get_unix_fd_list(msg);
  54         fds = g_unix_fd_list_peek_fds(fd_list, &fd_list_length);
  55
  56         if (fd_list_length <= 0)
  57                 DBG("D-Bus Message doesn't contain any fd!");
  58
  59         DBG("fd:%d\n", *fds);
  60
  61         result = vpn_service_init(arg_iface_name, arg_iface_name_len, *fds, &handle_s);
  62
  63         DBG("handle_s.fd : %d, handle_s.index : %d, handle_s.name : %s",
  64                         handle_s.fd, handle_s.index, handle_s.name);
  65
  66         vpnsvc_complete_vpn_init(object, invocation, result, handle_s.index, handle_s.name);
  67
  68         return TRUE;
  69 }
  70
  71 gboolean handle_vpn_deinit(Vpnsvc *object,
  72                                                                         GDBusMethodInvocation *invocation,
  73                                                                         const gchar *arg_dev_name)
  74 {
  75         DBG("handle_vpn_deinit");
  76
  77         int result = VPNSVC_ERROR_NONE;
  78
  79         DBG("vpn_deinit, %s\n", arg_dev_name);
  80
  81         result = vpn_service_deinit(arg_dev_name);
  82
  83         vpnsvc_complete_vpn_deinit(object, invocation, result);
  84
  85         return TRUE;
  86 }
  87
  88 gboolean handle_vpn_protect(Vpnsvc *object,
  89                                                                         GDBusMethodInvocation *invocation,
  90                                                                         const gchar *arg_dev_name)
  91 {
  92         DBG("handle_vpn_protect");
  93
  94         int result = VPNSVC_ERROR_NONE;
  95
  96         int socket;
  97         GDBusMessage *msg;
  98         GUnixFDList *fd_list;
  99         int fd_list_length;
 100         const int *fds;
 101
 102         msg = g_dbus_method_invocation_get_message(invocation);
 103         fd_list = g_dbus_message_get_unix_fd_list(msg);
 104         fds = g_unix_fd_list_peek_fds(fd_list, &fd_list_length);
 105         if (fd_list_length <= 0)
 106                 DBG("D-Bus Message doesn't contain any fd!");
 107
 108         socket = *fds;
 109         DBG("vpn_protect, %d, %s\n", socket, arg_dev_name);
 110
 111         result = vpn_service_protect(socket, arg_dev_name);
 112
 113         vpnsvc_complete_vpn_protect(object, invocation, result);
 114
 115         return TRUE;
 116 }
 117
 118 gboolean handle_vpn_up(Vpnsvc *object,
 119                                                                 GDBusMethodInvocation *invocation,
 120                                                                 const gchar *arg_iface_name)
 121 {
 122         DBG("handle_vpn_up");
 123
 124         int result = VPNSVC_ERROR_NONE;
 125
 126         result = vpn_service_up(arg_iface_name);
 127
 128         vpnsvc_complete_vpn_up(object, invocation, result);
 129
 130         return TRUE;
 131 }
 132
 133 gboolean handle_vpn_down(Vpnsvc *object,
 134                                                                         GDBusMethodInvocation *invocation,
 135                                                                         const gchar *arg_iface_name)
 136 {
 137         DBG("handle_vpn_down");
 138
 139         int result = VPNSVC_ERROR_NONE;
 140
 141         result = vpn_service_down(arg_iface_name);
 142
 143         vpnsvc_complete_vpn_down(object, invocation, result);
 144
 145         return TRUE;
 146 }
 147
 148 gboolean handle_vpn_block_networks(Vpnsvc *object,
 149                                                                                         GDBusMethodInvocation *invocation,
 150                                                                                         GVariant *arg_nets_vpn,
 151                                                                                         guint arg_nr_nets_vpn,
 152                                                                                         GVariant *arg_nets_orig,
 153                                                                                         guint arg_nr_nets_orig)
 154 {
 155         DBG("handle_vpn_block_networks");
 156
 157         int result = VPNSVC_ERROR_NONE;
 158
 159         char *nets_vpn[arg_nr_nets_vpn];
 160         int prefix_vpn[arg_nr_nets_vpn];
 161
 162         char *nets_orig[arg_nr_nets_vpn];
 163         int prefix_orig[arg_nr_nets_vpn];
 164
 165         int i = 0;
 166         GVariantIter iter;
 167         gchar* route_dest;
 168         gint route_prefix;
 169
 170         DBG("vpn_block_networks");
 171
 172         memset(nets_vpn, 0, sizeof(char *) * arg_nr_nets_vpn);
 173         memset(prefix_vpn, 0, sizeof(int) * arg_nr_nets_vpn);
 174         memset(nets_orig, 0, sizeof(char *) * arg_nr_nets_vpn);
 175         memset(prefix_orig, 0, sizeof(int) * arg_nr_nets_vpn);
 176
 177         /* arg_nets_vpn check */
 178         if (arg_nr_nets_vpn > 0) {
 179                 if (arg_nets_vpn != NULL) {
 180                         GVariant *dict_nets_vpn = g_variant_get_variant(arg_nets_vpn);
 181                         g_variant_iter_init(&iter, dict_nets_vpn);
 182                         i = 0;
 183                         while (g_variant_iter_loop(&iter, "{si}", &route_dest, &route_prefix)) {
 184                                 int tmp_route_len = strlen(route_dest);
 185                                 nets_vpn[i] = g_try_malloc0(sizeof(char) * tmp_route_len + 1);
 186                                 strncpy(nets_vpn[i], route_dest, tmp_route_len);
 187                                 nets_vpn[i][tmp_route_len] = '\0';
 188                                 prefix_vpn[i] = route_prefix;
 189                                 DBG("nets_vpn[%d] = %s \t", i, (nets_vpn[i] == NULL) ? "" : nets_vpn[i]);
 190                                 DBG("prefix_vpn[%d] = %d ", i, prefix_vpn[i]);
 191                                 i++;
 192                         }
 193                 }
 194         }
 195
 196         /* arg_nets_orig check */
 197         if (arg_nr_nets_orig > 0) {
 198                 if (arg_nets_orig != NULL) {
 199                         GVariant *dict_nets_orig = g_variant_get_variant(arg_nets_orig);
 200                         g_variant_iter_init(&iter, dict_nets_orig);
 201                         i = 0;
 202                         while (g_variant_iter_loop(&iter, "{si}", &route_dest, &route_prefix)) {
 203                                 int tmp_route_len = strlen(route_dest);
 204                                 nets_orig[i] = g_try_malloc0(sizeof(char) * tmp_route_len + 1);
 205                                 strncpy(nets_orig[i], route_dest, tmp_route_len);
 206                                 nets_orig[i][tmp_route_len] = '\0';
 207                                 prefix_orig[i] = route_prefix;
 208                                 DBG("nets_orig[%d] = %s \t", i, (nets_orig[i] == NULL) ? "" : nets_orig[i]);
 209                                 DBG("prefix_orig[%d] = %d ", i, prefix_orig[i]);
 210                                 i++;
 211                         }
 212                 }
 213         }
 214
 215         /* call function */
 216         result = vpn_service_block_networks(nets_vpn, prefix_vpn, arg_nr_nets_vpn, nets_orig, prefix_orig, arg_nr_nets_orig);
 217
 218         for (i = 0; i < arg_nr_nets_vpn; ++i) {
 219                 g_free(nets_orig[i]);
 220                 g_free(nets_vpn[i]);
 221         }
 222
 223         vpnsvc_complete_vpn_block_networks(object, invocation, result);
 224
 225         return TRUE;
 226 }
 227
 228 gboolean handle_vpn_unblock_networks(Vpnsvc *object,
 229                                                                                         GDBusMethodInvocation *invocation)
 230 {
 231         DBG("handle_vpn_unblock_networks");
 232
 233         int result = VPNSVC_ERROR_NONE;
 234
 235         DBG("vpn_unblock_networks");
 236
 237         result = vpn_service_unblock_networks();
 238
 239         vpnsvc_complete_vpn_unblock_networks(object, invocation, result);
 240
 241         return TRUE;
 242 }
 243
 244 gboolean handle_vpn_update_settings(Vpnsvc *object,
 245                                                                 GDBusMethodInvocation *invocation,
 246                                                                 gint arg_iface_index,
 247                                                                 const gchar *arg_local_ip,
 248                                                                 const gchar *arg_remote_ip,
 249                                                                 guint arg_mtu)
 250 {
 251         int result = VPNSVC_ERROR_NONE;
 252         DBG("handle_vpn_update_settings");
 253
 254         result = vpn_service_update_settings(arg_iface_index, arg_local_ip, arg_remote_ip, arg_mtu);
 255
 256         vpnsvc_complete_vpn_update_settings(object, invocation, result);
 257
 258         return TRUE;
 259 }
 260
 261 gboolean handle_vpn_add_route(Vpnsvc *object,
 262                                                                 GDBusMethodInvocation *invocation,
 263                                                                 gchar *arg_iface_name,
 264                                                                 const gchar *arg_route,
 265                                                                 gint arg_prefix)
 266 {
 267         DBG("handle_vpn_add_route");
 268
 269         int result = VPNSVC_ERROR_NONE;
 270
 271         result = vpn_service_add_route(arg_iface_name, arg_route, arg_prefix);
 272
 273         vpnsvc_complete_vpn_add_route(object, invocation, result);
 274
 275         return TRUE;
 276 }
 277
 278 gboolean handle_vpn_remove_route(Vpnsvc *object,
 279                                                                 GDBusMethodInvocation *invocation,
 280                                                                 gchar *arg_iface_name,
 281                                                                 const gchar *arg_route,
 282                                                                 gint arg_prefix)
 283
 284 {
 285         DBG("handle_vpn_remove_route");
 286
 287         int result = VPNSVC_ERROR_NONE;
 288
 289         result = vpn_service_remove_route(arg_iface_name, arg_route, arg_prefix);
 290
 291         vpnsvc_complete_vpn_remove_route(object, invocation, result);
 292
 293         return TRUE;
 294 }
 295
 296 gboolean handle_vpn_add_dns_server(Vpnsvc *object,
 297                                                                 GDBusMethodInvocation *invocation,
 298                                                                 gchar *arg_iface_name,
 299                                                                 const gchar *arg_dns_server)
 300 {
 301         DBG("handle_vpn_add_dns_server");
 302
 303         int result = VPNSVC_ERROR_NONE;
 304
 305         result = vpn_service_add_dns_server(arg_iface_name, arg_dns_server);
 306
 307         vpnsvc_complete_vpn_add_dns_server(object, invocation, result);
 308
 309         return TRUE;
 310 }
 311
 312 /*****************************
 313  * Initializations Functions *
 314  ****************************/
 315 Vpnsvc *get_vpnsvc_object(void)
 316 {
 317         return vpnsvc;
 318 }
 319
 320 void vpnsvc_create_and_init(void)
 321 {
 322         DBG("Create vpn object.");
 323         GDBusInterfaceSkeleton *interface_vpn = NULL;
 324         GDBusConnection *connection = NULL;
 325         GDBusObjectManagerServer *server = netdbus_get_vpn_manager();
 326         if (server == NULL)
 327                 return;
 328
 329         connection = netdbus_get_connection();
 330         g_dbus_object_manager_server_set_connection(server, connection);
 331
 332         /* Interface */
 333         vpnsvc = vpnsvc_skeleton_new();
 334         interface_vpn = G_DBUS_INTERFACE_SKELETON(vpnsvc);
 335
 336         /* VPN Service */
 337         g_signal_connect(vpnsvc, "handle-vpn-init",
 338                         G_CALLBACK(handle_vpn_init), NULL);
 339         g_signal_connect(vpnsvc, "handle-vpn-deinit",
 340                         G_CALLBACK(handle_vpn_deinit), NULL);
 341         g_signal_connect(vpnsvc, "handle-vpn-protect",
 342                         G_CALLBACK(handle_vpn_protect), NULL);
 343         g_signal_connect(vpnsvc, "handle-vpn-up",
 344                         G_CALLBACK(handle_vpn_up), NULL);
 345         g_signal_connect(vpnsvc, "handle-vpn-down",
 346                         G_CALLBACK(handle_vpn_down), NULL);
 347         g_signal_connect(vpnsvc, "handle-vpn-block-networks",
 348                         G_CALLBACK(handle_vpn_block_networks), NULL);
 349         g_signal_connect(vpnsvc, "handle-vpn-unblock-networks",
 350                         G_CALLBACK(handle_vpn_unblock_networks), NULL);
 351         g_signal_connect(vpnsvc, "handle-vpn-update-settings",
 352                         G_CALLBACK(handle_vpn_update_settings), NULL);
 353         g_signal_connect(vpnsvc, "handle-vpn-add-route",
 354                         G_CALLBACK(handle_vpn_add_route), NULL);
 355         g_signal_connect(vpnsvc, "handle-vpn-remove-route",
 356                         G_CALLBACK(handle_vpn_remove_route), NULL);
 357         g_signal_connect(vpnsvc, "handle-vpn-add-dns-server",
 358                         G_CALLBACK(handle_vpn_add_dns_server), NULL);
 359
 360         if (!g_dbus_interface_skeleton_export(interface_vpn, connection,
 361                         NETCONFIG_VPNSVC_PATH, NULL)) {
 362                 ERR("Export NETCONFIG_VPNSVC_PATH for vpn failed");
 363         }
 364
 365         return;
 366 }
 367
 368 void vpnsvc_destroy_deinit(void)
 369 {
 370         DBG("Deinit vpn object.");
 371
 372         if (vpnsvc)
 373                 g_object_unref(vpnsvc);
 374 }
 375