client/agent.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2013  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <sys/types.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31 #include <stdbool.h>
  32 #include <string.h>
  33 #include <ctype.h>
  34
  35 #include <gdbus.h>
  36
  37 #include "input.h"
  38 #include "dbus_helpers.h"
  39 #include "agent.h"
  40
  41 #define AGENT_INTERFACE      "net.connman.Agent"
  42 #define VPN_AGENT_INTERFACE  "net.connman.vpn.Agent"
  43
  44 static DBusConnection *agent_connection;
  45
  46 struct agent_input_data {
  47         const char *attribute;
  48         bool requested;
  49         char *prompt;
  50         connmanctl_input_func_t func;
  51 };
  52
  53 struct agent_data {
  54         struct agent_input_data *input;
  55         char *interface;
  56         bool registered;
  57         DBusMessage *message;
  58         DBusMessage *reply;
  59         DBusMessageIter iter;
  60         DBusMessageIter dict;
  61         GDBusMethodFunction pending_function;
  62 };
  63
  64 static void request_input_ssid_return(char *input, void *user_data);
  65 static void request_input_passphrase_return(char *input, void *user_data);
  66 static void request_input_string_return(char *input, void *user_data);
  67
  68 enum requestinput {
  69         SSID                    = 0,
  70         IDENTITY                = 1,
  71         PASSPHRASE              = 2,
  72         WPS                     = 3,
  73         WISPR_USERNAME          = 4,
  74         WISPR_PASSPHRASE        = 5,
  75         REQUEST_INPUT_MAX       = 6,
  76 };
  77
  78 static struct agent_input_data agent_input_handler[] = {
  79         { "Name", false, "Hidden SSID name? ", request_input_ssid_return },
  80         { "Identity", false, "EAP username? ", request_input_string_return },
  81         { "Passphrase", false, "Passphrase? ",
  82           request_input_passphrase_return },
  83         { "WPS", false, "WPS PIN (empty line for pushbutton)? " ,
  84           request_input_string_return },
  85         { "Username", false, "WISPr username? ", request_input_string_return },
  86         { "Password", false, "WISPr password? ", request_input_string_return },
  87         { },
  88 };
  89
  90 static struct agent_data agent_request = {
  91         agent_input_handler,
  92         AGENT_INTERFACE,
  93 };
  94
  95 static struct agent_input_data vpnagent_input_handler[] = {
  96         { "OpenConnect.Cookie", false, "OpenConnect Cookie? ",
  97           request_input_string_return },
  98         { "OpenConnect.ServerCert", false,
  99           "OpenConnect server certificate hash? ",
 100           request_input_string_return },
 101         { "OpenConnect.VPNHost", false, "OpenConnect VPN server? ",
 102           request_input_string_return },
 103         { "Username", false, "VPN username? ", request_input_string_return },
 104         { "Password", false, "VPN password? ", request_input_string_return },
 105         { },
 106 };
 107
 108 static struct agent_data vpn_agent_request = {
 109         vpnagent_input_handler,
 110         VPN_AGENT_INTERFACE,
 111 };
 112
 113 static int confirm_input(char *input)
 114 {
 115         int i;
 116
 117         if (!input)
 118                 return -1;
 119
 120         for (i = 0; input[i] != '\0'; i++)
 121                 if (isspace(input[i]) == 0)
 122                         break;
 123
 124         if (strcasecmp(&input[i], "yes") == 0 ||
 125                         strcasecmp(&input[i], "y") == 0)
 126                 return 1;
 127
 128         if (strcasecmp(&input[i], "no") == 0 ||
 129                         strcasecmp(&input[i], "n") == 0)
 130                 return 0;
 131
 132         return -1;
 133 }
 134
 135 static char *strip_path(char *path)
 136 {
 137         char *name = strrchr(path, '/');
 138         if (name)
 139                 name++;
 140         else
 141                 name = path;
 142
 143         return name;
 144 }
 145
 146 static char *agent_path(void)
 147 {
 148         static char *path = NULL;
 149
 150         if (!path)
 151                 path = g_strdup_printf("/net/connman/connmanctl%d", getpid());
 152
 153         return path;
 154 }
 155
 156 static void pending_message_remove(struct agent_data *request)
 157 {
 158         if (request->message) {
 159                 dbus_message_unref(request->message);
 160                 request->message = NULL;
 161         }
 162
 163         if (request->reply) {
 164                 dbus_message_unref(request->reply);
 165                 request->reply = NULL;
 166         }
 167 }
 168
 169 static void pending_command_complete(char *message)
 170 {
 171         struct agent_data *next_request = NULL;
 172         DBusMessage *pending_message;
 173         GDBusMethodFunction pending_function;
 174
 175         __connmanctl_save_rl();
 176
 177         fprintf(stdout, "%s", message);
 178
 179         __connmanctl_redraw_rl();
 180
 181         if (__connmanctl_is_interactive() == true)
 182                 __connmanctl_command_mode();
 183         else
 184                 __connmanctl_agent_mode("", NULL, NULL);
 185
 186         if (agent_request.message)
 187                 next_request = &agent_request;
 188         else if (vpn_agent_request.message)
 189                 next_request = &vpn_agent_request;
 190
 191         if (!next_request)
 192                 return;
 193
 194         pending_message = next_request->message;
 195         pending_function = next_request->pending_function;
 196         next_request->pending_function = NULL;
 197
 198         pending_function(agent_connection, next_request->message,
 199                         next_request);
 200
 201         dbus_message_unref(pending_message);
 202 }
 203
 204 static bool handle_message(DBusMessage *message, struct agent_data *request,
 205                 GDBusMethodFunction function)
 206 {
 207         if (!agent_request.pending_function &&
 208                         !vpn_agent_request.pending_function)
 209                 return true;
 210
 211         request->message = dbus_message_ref(message);
 212         request->pending_function = function;
 213
 214         return false;
 215 }
 216
 217 static DBusMessage *agent_release(DBusConnection *connection,
 218                 DBusMessage *message, void *user_data)
 219 {
 220         struct agent_data *request = user_data;
 221
 222         if (handle_message(message, request, agent_release) == false)
 223                 return NULL;
 224
 225         g_dbus_unregister_interface(connection, agent_path(),
 226                         request->interface);
 227         request->registered = false;
 228
 229         pending_message_remove(request);
 230
 231         if (strcmp(request->interface, AGENT_INTERFACE) == 0)
 232                 pending_command_complete("Agent unregistered by ConnMan\n");
 233         else
 234                 pending_command_complete("VPN Agent unregistered by ConnMan "
 235                                 "VPNd\n");
 236
 237         if (__connmanctl_is_interactive() == false)
 238                 __connmanctl_quit();
 239
 240         return dbus_message_new_method_return(message);
 241 }
 242
 243 static DBusMessage *agent_cancel(DBusConnection *connection,
 244                 DBusMessage *message, void *user_data)
 245 {
 246         struct agent_data *request = user_data;
 247
 248         if (handle_message(message, request, agent_cancel) == false)
 249                 return NULL;
 250
 251         pending_message_remove(request);
 252
 253         if (strcmp(request->interface, AGENT_INTERFACE) == 0)
 254                 pending_command_complete("Agent request cancelled by "
 255                                 "ConnMan\n");
 256         else
 257                 pending_command_complete("VPN Agent request cancelled by "
 258                                 "ConnMan VPNd\n");
 259
 260         return dbus_message_new_method_return(message);
 261 }
 262
 263 static void request_browser_return(char *input, void *user_data)
 264 {
 265         struct agent_data *request = user_data;
 266
 267         switch (confirm_input(input)) {
 268         case 1:
 269                 g_dbus_send_reply(agent_connection, request->message,
 270                                 DBUS_TYPE_INVALID);
 271                 break;
 272         case 0:
 273                 g_dbus_send_error(agent_connection, request->message,
 274                                 "net.connman.Agent.Error.Canceled", NULL);
 275                 break;
 276         default:
 277                 return;
 278         }
 279
 280         pending_message_remove(request);
 281         pending_command_complete("");
 282 }
 283
 284 static DBusMessage *agent_request_browser(DBusConnection *connection,
 285                 DBusMessage *message, void *user_data)
 286 {
 287         struct agent_data *request = user_data;
 288         DBusMessageIter iter;
 289         char *service, *url;
 290
 291         if (handle_message(message, request, agent_request_browser) == false)
 292                 return NULL;
 293
 294         dbus_message_iter_init(message, &iter);
 295
 296         dbus_message_iter_get_basic(&iter, &service);
 297         dbus_message_iter_next(&iter);
 298         dbus_message_iter_get_basic(&iter, &url);
 299
 300         __connmanctl_save_rl();
 301         fprintf(stdout, "Agent RequestBrowser %s\n", strip_path(service));
 302         fprintf(stdout, "  %s\n", url);
 303         __connmanctl_redraw_rl();
 304
 305         request->message = dbus_message_ref(message);
 306         __connmanctl_agent_mode("Connected (yes/no)? ",
 307                         request_browser_return, request);
 308
 309         return NULL;
 310 }
 311
 312 static void report_error_return(char *input, void *user_data)
 313 {
 314         struct agent_data *request = user_data;
 315
 316         switch (confirm_input(input)) {
 317         case 1:
 318                 if (strcmp(request->interface, AGENT_INTERFACE) == 0)
 319                         g_dbus_send_error(agent_connection, request->message,
 320                                         "net.connman.Agent.Error.Retry", NULL);
 321                 else
 322                         g_dbus_send_error(agent_connection, request->message,
 323                                         "net.connman.vpn.Agent.Error.Retry",
 324                                         NULL);
 325                 break;
 326         case 0:
 327                 g_dbus_send_reply(agent_connection, request->message,
 328                                 DBUS_TYPE_INVALID);
 329                 break;
 330         default:
 331                 return;
 332         }
 333
 334         pending_message_remove(request);
 335         pending_command_complete("");
 336 }
 337
 338 static DBusMessage *agent_report_error(DBusConnection *connection,
 339                 DBusMessage *message, void *user_data)
 340 {
 341         struct agent_data *request = user_data;
 342         DBusMessageIter iter;
 343         char *path, *service, *error;
 344
 345         if (handle_message(message, request, agent_report_error) == false)
 346                 return NULL;
 347
 348         dbus_message_iter_init(message, &iter);
 349
 350         dbus_message_iter_get_basic(&iter, &path);
 351         service = strip_path(path);
 352
 353         dbus_message_iter_next(&iter);
 354         dbus_message_iter_get_basic(&iter, &error);
 355
 356         __connmanctl_save_rl();
 357         if (strcmp(request->interface, AGENT_INTERFACE) == 0)
 358                 fprintf(stdout, "Agent ReportError %s\n", service);
 359         else
 360                 fprintf(stdout, "VPN Agent ReportError %s\n", service);
 361         fprintf(stdout, "  %s\n", error);
 362         __connmanctl_redraw_rl();
 363
 364         request->message = dbus_message_ref(message);
 365         __connmanctl_agent_mode("Retry (yes/no)? ", report_error_return,
 366                         request);
 367
 368         return NULL;
 369 }
 370
 371 static void request_input_next(struct agent_data *request)
 372 {
 373         int i;
 374
 375         for (i = 0; request->input[i].attribute; i++) {
 376                 if (request->input[i].requested == true) {
 377                         if (request->input[i].func)
 378                                 __connmanctl_agent_mode(request->input[i].prompt,
 379                                                 request->input[i].func,
 380                                                 request);
 381                         else
 382                                 request->input[i].requested = false;
 383                         return;
 384                 }
 385         }
 386
 387         dbus_message_iter_close_container(&request->iter, &request->dict);
 388
 389         g_dbus_send_message(agent_connection, request->reply);
 390         request->reply = NULL;
 391
 392         pending_message_remove(request);
 393         pending_command_complete("");
 394
 395         __connmanctl_redraw_rl();
 396 }
 397
 398 static void request_input_append(struct agent_data *request,
 399                 const char *attribute, char *value)
 400 {
 401         __connmanctl_dbus_append_dict_entry(&request->dict, attribute,
 402                         DBUS_TYPE_STRING, &value);
 403 }
 404
 405 static void request_input_ssid_return(char *input,
 406                 void *user_data)
 407 {
 408         struct agent_data *request = user_data;
 409         int len = 0;
 410
 411         if (input)
 412                 len = strlen(input);
 413
 414         if (len > 0 && len <= 32) {
 415                 request->input[SSID].requested = false;
 416                 request_input_append(request, request->input[SSID].attribute,
 417                                 input);
 418
 419                 request_input_next(request);
 420         }
 421 }
 422
 423 static void request_input_passphrase_return(char *input, void *user_data)
 424 {
 425         struct agent_data *request = user_data;
 426         int len = 0;
 427
 428         /* TBD passphrase length checking */
 429
 430         if (input)
 431                 len = strlen(input);
 432
 433         if (len == 0 && request->input[WPS].requested == false)
 434                 return;
 435
 436         request->input[PASSPHRASE].requested = false;
 437
 438         if (len > 0) {
 439                 request_input_append(request,
 440                                 request->input[PASSPHRASE].attribute, input);
 441
 442                 request->input[WPS].requested = false;
 443         }
 444
 445         request_input_next(request);
 446 }
 447
 448 static void request_input_string_return(char *input, void *user_data)
 449 {
 450         struct agent_data *request = user_data;
 451         int i;
 452
 453         for (i = 0; request->input[i].attribute; i++) {
 454                 if (request->input[i].requested == true) {
 455                         request_input_append(request,
 456                                         request->input[i].attribute, input);
 457                         request->input[i].requested = false;
 458                         break;
 459                 }
 460         }
 461
 462         request_input_next(request);
 463 }
 464
 465 static DBusMessage *agent_request_input(DBusConnection *connection,
 466                 DBusMessage *message, void *user_data)
 467 {
 468         struct agent_data *request = user_data;
 469         DBusMessageIter iter, dict, entry, variant;
 470         char *service, *str, *field;
 471         DBusMessageIter dict_entry, field_entry, field_value;
 472         char *argument, *value, *attr_type = NULL;
 473
 474         int i;
 475
 476         if (handle_message(message, request, agent_request_input) == false)
 477                 return NULL;
 478
 479         dbus_message_iter_init(message, &iter);
 480
 481         dbus_message_iter_get_basic(&iter, &str);
 482         service = strip_path(str);
 483
 484         dbus_message_iter_next(&iter);
 485         dbus_message_iter_recurse(&iter, &dict);
 486
 487         __connmanctl_save_rl();
 488         if (strcmp(request->interface, AGENT_INTERFACE) == 0)
 489                 fprintf(stdout, "Agent RequestInput %s\n", service);
 490         else
 491                 fprintf(stdout, "VPN Agent RequestInput %s\n", service);
 492         __connmanctl_dbus_print(&dict, "  ", " = ", "\n");
 493         fprintf(stdout, "\n");
 494
 495         dbus_message_iter_recurse(&iter, &dict);
 496
 497         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 498
 499                 dbus_message_iter_recurse(&dict, &entry);
 500
 501                 dbus_message_iter_get_basic(&entry, &field);
 502
 503                 dbus_message_iter_next(&entry);
 504
 505                 dbus_message_iter_recurse(&entry, &variant);
 506                 dbus_message_iter_recurse(&variant, &dict_entry);
 507
 508                 while (dbus_message_iter_get_arg_type(&dict_entry)
 509                                 == DBUS_TYPE_DICT_ENTRY) {
 510                         dbus_message_iter_recurse(&dict_entry, &field_entry);
 511
 512                         dbus_message_iter_get_basic(&field_entry, &argument);
 513
 514                         dbus_message_iter_next(&field_entry);
 515
 516                         dbus_message_iter_recurse(&field_entry, &field_value);
 517
 518                         if (strcmp(argument, "Type") == 0) {
 519                                 dbus_message_iter_get_basic(&field_value,
 520                                                 &value);
 521                                 attr_type = g_strdup(value);
 522                         }
 523
 524                         dbus_message_iter_next(&dict_entry);
 525                 }
 526
 527                 for (i = 0; request->input[i].attribute; i++) {
 528                         if (strcmp(field, request->input[i].attribute) == 0) {
 529                                 request->input[i].requested = true;
 530                                 break;
 531                         }
 532                 }
 533
 534                 g_free(attr_type);
 535                 attr_type = NULL;
 536
 537                 dbus_message_iter_next(&dict);
 538         }
 539
 540         request->reply = dbus_message_new_method_return(message);
 541         dbus_message_iter_init_append(request->reply, &request->iter);
 542
 543         dbus_message_iter_open_container(&request->iter, DBUS_TYPE_ARRAY,
 544                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 545                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 546                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 547                         &request->dict);
 548
 549         request_input_next(request);
 550
 551         return NULL;
 552 }
 553
 554 static const GDBusMethodTable agent_methods[] = {
 555         { GDBUS_ASYNC_METHOD("Release", NULL, NULL, agent_release) },
 556         { GDBUS_ASYNC_METHOD("Cancel", NULL, NULL, agent_cancel) },
 557         { GDBUS_ASYNC_METHOD("RequestBrowser",
 558                                 GDBUS_ARGS({ "service", "o" },
 559                                         { "url", "s" }),
 560                                 NULL, agent_request_browser) },
 561         { GDBUS_ASYNC_METHOD("ReportError",
 562                                 GDBUS_ARGS({ "service", "o" },
 563                                         { "error", "s" }),
 564                                 NULL, agent_report_error) },
 565         { GDBUS_ASYNC_METHOD("RequestInput",
 566                                 GDBUS_ARGS({ "service", "o" },
 567                                         { "fields", "a{sv}" }),
 568                                 GDBUS_ARGS({ "fields", "a{sv}" }),
 569                                 agent_request_input) },
 570         { },
 571 };
 572
 573 static int agent_register_return(DBusMessageIter *iter, const char *error,
 574                 void *user_data)
 575 {
 576         DBusConnection *connection = user_data;
 577
 578         if (error) {
 579                 g_dbus_unregister_interface(connection, agent_path(),
 580                                 AGENT_INTERFACE);
 581                 fprintf(stderr, "Error registering Agent: %s\n", error);
 582                 return 0;
 583         }
 584
 585         agent_request.registered = true;
 586         fprintf(stdout, "Agent registered\n");
 587
 588         return -EINPROGRESS;
 589 }
 590
 591 static void append_path(DBusMessageIter *iter, void *user_data)
 592 {
 593         const char *path = user_data;
 594
 595         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
 596 }
 597
 598 int __connmanctl_agent_register(DBusConnection *connection)
 599 {
 600         char *path = agent_path();
 601         int result;
 602
 603         if (agent_request.registered == true) {
 604                 fprintf(stderr, "Agent already registered\n");
 605                 return -EALREADY;
 606         }
 607
 608         agent_connection = connection;
 609
 610         if (!g_dbus_register_interface(connection, path,
 611                                         AGENT_INTERFACE, agent_methods,
 612                                         NULL, NULL, &agent_request, NULL)) {
 613                 fprintf(stderr, "Error: Failed to register Agent callbacks\n");
 614                 return 0;
 615         }
 616
 617         result = __connmanctl_dbus_method_call(connection, CONNMAN_SERVICE,
 618                         CONNMAN_PATH, "net.connman.Manager", "RegisterAgent",
 619                         agent_register_return, connection, append_path, path);
 620
 621         if (result != -EINPROGRESS) {
 622                 g_dbus_unregister_interface(connection, agent_path(),
 623                                 AGENT_INTERFACE);
 624
 625                 fprintf(stderr, "Error: Failed to register Agent\n");
 626         }
 627
 628         return result;
 629 }
 630
 631 static int agent_unregister_return(DBusMessageIter *iter, const char *error,
 632                 void *user_data)
 633 {
 634         if (error) {
 635                 fprintf(stderr, "Error unregistering Agent: %s\n", error);
 636                 return 0;
 637         }
 638
 639         agent_request.registered = false;
 640         fprintf(stdout, "Agent unregistered\n");
 641
 642         return 0;
 643 }
 644
 645 int __connmanctl_agent_unregister(DBusConnection *connection)
 646 {
 647         char *path = agent_path();
 648         int result;
 649
 650         if (agent_request.registered == false) {
 651                 fprintf(stderr, "Agent not registered\n");
 652                 return -EALREADY;
 653         }
 654
 655         g_dbus_unregister_interface(connection, agent_path(), AGENT_INTERFACE);
 656
 657         result = __connmanctl_dbus_method_call(connection, CONNMAN_SERVICE,
 658                         CONNMAN_PATH, "net.connman.Manager", "UnregisterAgent",
 659                         agent_unregister_return, NULL, append_path, path);
 660
 661         if (result != -EINPROGRESS)
 662                 fprintf(stderr, "Error: Failed to unregister Agent\n");
 663
 664         return result;
 665 }
 666
 667 static const GDBusMethodTable vpn_agent_methods[] = {
 668         { GDBUS_ASYNC_METHOD("Release", NULL, NULL, agent_release) },
 669         { GDBUS_ASYNC_METHOD("Cancel", NULL, NULL, agent_cancel) },
 670         { GDBUS_ASYNC_METHOD("ReportError",
 671                                 GDBUS_ARGS({ "service", "o" },
 672                                         { "error", "s" }),
 673                                 NULL, agent_report_error) },
 674         { GDBUS_ASYNC_METHOD("RequestInput",
 675                                 GDBUS_ARGS({ "service", "o" },
 676                                         { "fields", "a{sv}" }),
 677                                 GDBUS_ARGS({ "fields", "a{sv}" }),
 678                                 agent_request_input) },
 679         { },
 680 };
 681
 682 static int vpn_agent_register_return(DBusMessageIter *iter, const char *error,
 683                 void *user_data)
 684 {
 685         DBusConnection *connection = user_data;
 686
 687         if (error) {
 688                 g_dbus_unregister_interface(connection, agent_path(),
 689                                 VPN_AGENT_INTERFACE);
 690                 fprintf(stderr, "Error registering VPN Agent: %s\n", error);
 691                 return 0;
 692         }
 693
 694         vpn_agent_request.registered = true;
 695         fprintf(stdout, "VPN Agent registered\n");
 696
 697         return -EINPROGRESS;
 698 }
 699
 700 int __connmanctl_vpn_agent_register(DBusConnection *connection)
 701 {
 702         char *path = agent_path();
 703         int result;
 704
 705         if (vpn_agent_request.registered == true) {
 706                 fprintf(stderr, "VPN Agent already registered\n");
 707                 return -EALREADY;
 708         }
 709
 710         agent_connection = connection;
 711
 712         if (!g_dbus_register_interface(connection, path,
 713                         VPN_AGENT_INTERFACE, vpn_agent_methods,
 714                         NULL, NULL, &vpn_agent_request, NULL)) {
 715                 fprintf(stderr, "Error: Failed to register VPN Agent "
 716                                 "callbacks\n");
 717                 return 0;
 718         }
 719
 720         result = __connmanctl_dbus_method_call(connection, VPN_SERVICE,
 721                         VPN_PATH, "net.connman.vpn.Manager", "RegisterAgent",
 722                         vpn_agent_register_return, connection, append_path,
 723                         path);
 724
 725         if (result != -EINPROGRESS) {
 726                 g_dbus_unregister_interface(connection, agent_path(),
 727                                 VPN_AGENT_INTERFACE);
 728
 729                 fprintf(stderr, "Error: Failed to register VPN Agent\n");
 730         }
 731
 732         return result;
 733 }
 734
 735 static int vpn_agent_unregister_return(DBusMessageIter *iter,
 736                 const char *error, void *user_data)
 737 {
 738         if (error) {
 739                 fprintf(stderr, "Error unregistering VPN Agent: %s\n", error);
 740                 return 0;
 741         }
 742
 743         vpn_agent_request.registered = false;
 744         fprintf(stdout, "VPN Agent unregistered\n");
 745
 746         return 0;
 747 }
 748
 749 int __connmanctl_vpn_agent_unregister(DBusConnection *connection)
 750 {
 751         char *path = agent_path();
 752         int result;
 753
 754         if (vpn_agent_request.registered == false) {
 755                 fprintf(stderr, "VPN Agent not registered\n");
 756                 return -EALREADY;
 757         }
 758
 759         g_dbus_unregister_interface(connection, agent_path(),
 760                         VPN_AGENT_INTERFACE);
 761
 762         result = __connmanctl_dbus_method_call(connection, VPN_SERVICE,
 763                         VPN_PATH, "net.connman.vpn.Manager", "UnregisterAgent",
 764                         vpn_agent_unregister_return, NULL, append_path, path);
 765
 766         if (result != -EINPROGRESS)
 767                 fprintf(stderr, "Error: Failed to unregister VPN Agent\n");
 768
 769         return result;
 770 }