5 * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
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.
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.
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
37 #include "dbus_helpers.h"
42 static DBusConnection *connection;
44 static char *ipv4[] = {
52 static char *ipv6[] = {
60 static int cmd_help(char *args[], int num, struct option *options);
62 static int parse_boolean(char *arg)
67 if (strcasecmp(arg, "no") == 0 ||
68 strcasecmp(arg, "false") == 0 ||
69 strcasecmp(arg, "off" ) == 0 ||
70 strcasecmp(arg, "disable" ) == 0 ||
71 strcasecmp(arg, "n") == 0 ||
72 strcasecmp(arg, "f") == 0 ||
73 strcasecmp(arg, "0") == 0)
76 if (strcasecmp(arg, "yes") == 0 ||
77 strcasecmp(arg, "true") == 0 ||
78 strcasecmp(arg, "on") == 0 ||
79 strcasecmp(arg, "enable" ) == 0 ||
80 strcasecmp(arg, "y") == 0 ||
81 strcasecmp(arg, "t") == 0 ||
82 strcasecmp(arg, "1") == 0)
88 static int parse_args(char *arg, struct option *options)
95 for (i = 0; options[i].name != NULL; i++) {
96 if (strcmp(options[i].name, arg) == 0 ||
97 (strncmp(arg, "--", 2) == 0 &&
98 strcmp(&arg[2], options[i].name) == 0))
99 return options[i].val;
105 static void enable_return(DBusMessageIter *iter, const char *error,
108 char *tech = user_data;
111 str = strrchr(tech, '/');
118 fprintf(stdout, "Enabled %s\n", str);
120 fprintf(stderr, "Error %s: %s\n", str, error);
125 static int cmd_enable(char *args[], int num, struct option *options)
128 dbus_bool_t b = TRUE;
136 if (strcmp(args[1], "offlinemode") == 0) {
137 tech = g_strdup(args[1]);
138 return __connmanctl_dbus_set_property(connection, "/",
139 "net.connman.Manager", enable_return, tech,
140 "OfflineMode", DBUS_TYPE_BOOLEAN, &b);
143 tech = g_strdup_printf("/net/connman/technology/%s", args[1]);
144 return __connmanctl_dbus_set_property(connection, tech,
145 "net.connman.Technology", enable_return, tech,
146 "Powered", DBUS_TYPE_BOOLEAN, &b);
149 static void disable_return(DBusMessageIter *iter, const char *error,
152 char *tech = user_data;
155 str = strrchr(tech, '/');
162 fprintf(stdout, "Disabled %s\n", str);
164 fprintf(stderr, "Error %s: %s\n", str, error);
169 static int cmd_disable(char *args[], int num, struct option *options)
172 dbus_bool_t b = FALSE;
180 if (strcmp(args[1], "offlinemode") == 0) {
181 tech = g_strdup(args[1]);
182 return __connmanctl_dbus_set_property(connection, "/",
183 "net.connman.Manager", disable_return, tech,
184 "OfflineMode", DBUS_TYPE_BOOLEAN, &b);
187 tech = g_strdup_printf("/net/connman/technology/%s", args[1]);
188 return __connmanctl_dbus_set_property(connection, tech,
189 "net.connman.Technology", disable_return, tech,
190 "Powered", DBUS_TYPE_BOOLEAN, &b);
193 static void state_print(DBusMessageIter *iter, const char *error,
196 DBusMessageIter entry;
199 fprintf(stderr, "Error: %s", error);
203 dbus_message_iter_recurse(iter, &entry);
204 __connmanctl_dbus_print(&entry, " ", " = ", "\n");
205 fprintf(stdout, "\n");
208 static int cmd_state(char *args[], int num, struct option *options)
213 return __connmanctl_dbus_method_call(connection, "/",
214 "net.connman.Manager", "GetProperties",
215 state_print, NULL, DBUS_TYPE_INVALID);
218 static void services_list(DBusMessageIter *iter, const char *error,
222 __connmanctl_services_list(iter);
223 fprintf(stdout, "\n");
225 fprintf(stderr, "Error: %s\n", error);
229 static void services_properties(DBusMessageIter *iter, const char *error,
232 char *path = user_data;
234 DBusMessageIter dict;
237 fprintf(stdout, "%s\n", path);
239 dbus_message_iter_recurse(iter, &dict);
240 __connmanctl_dbus_print(&dict, " ", " = ", "\n");
242 fprintf(stdout, "\n");
245 str = strrchr(path, '/');
251 fprintf(stderr, "Error %s: %s\n", str, error);
257 static int cmd_services(char *args[], int num, struct option *options)
259 char *service_name = NULL;
266 c = parse_args(args[1], options);
273 service_name = args[2];
278 service_name = args[1];
282 if (service_name == NULL) {
283 return __connmanctl_dbus_method_call(connection, "/",
284 "net.connman.Manager", "GetServices",
285 services_list, NULL, DBUS_TYPE_INVALID);
288 path = g_strdup_printf("/net/connman/service/%s", service_name);
289 return __connmanctl_dbus_method_call(connection, path,
290 "net.connman.Service", "GetProperties",
291 services_properties, path, DBUS_TYPE_INVALID);
294 static void technology_print(DBusMessageIter *iter, const char *error,
297 DBusMessageIter array;
300 fprintf(stderr, "Error: %s\n", error);
304 dbus_message_iter_recurse(iter, &array);
305 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRUCT) {
306 DBusMessageIter entry, dict;
309 dbus_message_iter_recurse(&array, &entry);
310 dbus_message_iter_get_basic(&entry, &path);
311 fprintf(stdout, "%s\n", path);
313 dbus_message_iter_next(&entry);
315 dbus_message_iter_recurse(&entry, &dict);
316 __connmanctl_dbus_print(&dict, " ", " = ", "\n");
317 fprintf(stdout, "\n");
319 dbus_message_iter_next(&array);
323 static int cmd_technologies(char *args[], int num, struct option *options)
328 return __connmanctl_dbus_method_call(connection, "/",
329 "net.connman.Manager", "GetTechnologies",
330 technology_print, NULL, DBUS_TYPE_INVALID);
333 struct tether_enable {
338 static void tether_set_return(DBusMessageIter *iter, const char *error,
341 struct tether_enable *tether = user_data;
344 str = strrchr(tether->path, '/');
351 fprintf(stdout, "%s tethering for %s\n",
352 tether->enable == TRUE ? "Enabled": "Disabled",
355 fprintf(stderr, "Error %s %s tethering: %s\n",
356 tether->enable == TRUE ?
357 "enabling": "disabling", str, error);
359 g_free(tether->path);
363 static int tether_set(char *technology, int set_tethering)
365 struct tether_enable *tether = g_new(struct tether_enable, 1);
367 switch(set_tethering) {
369 tether->enable = TRUE;
372 tether->enable = FALSE;
379 tether->path = g_strdup_printf("/net/connman/technology/%s",
382 return __connmanctl_dbus_set_property(connection, tether->path,
383 "net.connman.Technology", tether_set_return,
384 tether, "Tethering", DBUS_TYPE_BOOLEAN,
388 struct tether_properties {
390 int passphrase_result;
394 static void tether_update(struct tether_properties *tether)
396 printf("%d %d %d\n", tether->ssid_result, tether->passphrase_result,
397 tether->set_tethering);
399 if (tether->ssid_result == 0 && tether->passphrase_result == 0)
400 tether_set("wifi", tether->set_tethering);
402 if (tether->ssid_result != -EINPROGRESS &&
403 tether->passphrase_result != -EINPROGRESS)
407 static void tether_set_ssid_return(DBusMessageIter *iter, const char *error,
410 struct tether_properties *tether = user_data;
413 fprintf(stdout, "Wifi SSID set\n");
414 tether->ssid_result = 0;
416 fprintf(stderr, "Error setting wifi SSID: %s\n", error);
417 tether->ssid_result = -EINVAL;
420 tether_update(tether);
423 static void tether_set_passphrase_return(DBusMessageIter *iter,
424 const char *error, void *user_data)
426 struct tether_properties *tether = user_data;
429 fprintf(stdout, "Wifi passphrase set\n");
430 tether->passphrase_result = 0;
432 fprintf(stderr, "Error setting wifi passphrase: %s\n", error);
433 tether->passphrase_result = -EINVAL;
436 tether_update(tether);
439 static int tether_set_ssid(char *ssid, char *passphrase, int set_tethering)
441 struct tether_properties *tether = g_new(struct tether_properties, 1);
443 tether->set_tethering = set_tethering;
445 tether->ssid_result = __connmanctl_dbus_set_property(connection,
446 "/net/connman/technology/wifi",
447 "net.connman.Technology",
448 tether_set_ssid_return, tether,
449 "TetheringIdentifier", DBUS_TYPE_STRING, &ssid);
451 tether->passphrase_result =__connmanctl_dbus_set_property(connection,
452 "/net/connman/technology/wifi",
453 "net.connman.Technology",
454 tether_set_passphrase_return, tether,
455 "TetheringPassphrase", DBUS_TYPE_STRING, &passphrase);
457 if (tether->ssid_result != -EINPROGRESS &&
458 tether->passphrase_result != -EINPROGRESS) {
466 static int cmd_tether(char *args[], int num, struct option *options)
468 char *ssid, *passphrase;
474 passphrase = args[num - 1];
475 ssid = args[num - 2];
477 set_tethering = parse_boolean(args[2]);
479 if (strcmp(args[1], "wifi") == 0) {
484 if (num == 5 && set_tethering == -1)
491 return tether_set_ssid(ssid, passphrase, set_tethering);
497 if (set_tethering == -1)
500 return tether_set(args[1], set_tethering);
503 static void scan_return(DBusMessageIter *iter, const char *error,
506 char *path = user_data;
509 char *str = strrchr(path, '/');
511 fprintf(stdout, "Scan completed for %s\n", str);
513 fprintf(stderr, "Error %s: %s", path, error);
518 static int cmd_scan(char *args[], int num, struct option *options)
528 path = g_strdup_printf("/net/connman/technology/%s", args[1]);
529 return __connmanctl_dbus_method_call(connection, path,
530 "net.connman.Technology", "Scan",
531 scan_return, path, DBUS_TYPE_INVALID);
534 static void connect_return(DBusMessageIter *iter, const char *error,
537 char *path = user_data;
540 char *str = strrchr(path, '/');
542 fprintf(stdout, "Connected %s\n", str);
544 fprintf(stderr, "Error %s: %s\n", path, error);
549 static int cmd_connect(char *args[], int num, struct option *options)
559 path = g_strdup_printf("/net/connman/service/%s", args[1]);
560 return __connmanctl_dbus_method_call(connection, path,
561 "net.connman.Service", "Connect",
562 connect_return, path, DBUS_TYPE_INVALID);
565 static void disconnect_return(DBusMessageIter *iter, const char *error,
568 char *path = user_data;
571 char *str = strrchr(path, '/');
573 fprintf(stdout, "Disconnected %s\n", str);
575 fprintf(stderr, "Error %s: %s\n", path, error);
580 static int cmd_disconnect(char *args[], int num, struct option *options)
590 path = g_strdup_printf("/net/connman/service/%s", args[1]);
591 return __connmanctl_dbus_method_call(connection, path,
592 "net.connman.Service", "Disconnect",
593 disconnect_return, path, DBUS_TYPE_INVALID);
598 static void config_return(DBusMessageIter *iter, const char *error,
601 char *service_name = user_data;
604 fprintf(stderr, "Error %s: %s\n", service_name, error);
609 struct config_append {
614 static void config_append_ipv4(DBusMessageIter *iter,
617 struct config_append *append = user_data;
618 char **opts = append->opts;
624 while (opts[i] != NULL && ipv4[i] != NULL) {
625 __connmanctl_dbus_append_dict_entry(iter, ipv4[i],
626 DBUS_TYPE_STRING, &opts[i]);
633 static void config_append_ipv6(DBusMessageIter *iter, void *user_data)
635 struct config_append *append = user_data;
636 char **opts = append->opts;
643 if (g_strcmp0(opts[0], "auto") == 0) {
646 switch (parse_boolean(opts[1])) {
651 __connmanctl_dbus_append_dict_entry(iter, "Privacy",
652 DBUS_TYPE_STRING, &str);
659 __connmanctl_dbus_append_dict_entry(iter, "Privacy",
660 DBUS_TYPE_STRING, &str);
664 if (opts[1] != NULL) {
667 if (g_strcmp0(opts[0], "prefered") != 0) {
668 fprintf(stderr, "Error %s: %s\n",
675 __connmanctl_dbus_append_dict_entry(iter,
676 "Privacy", DBUS_TYPE_STRING,
681 } else if (g_strcmp0(opts[0], "manual") == 0) {
684 while (opts[i] != NULL && ipv6[i] != NULL) {
686 int value = atoi(opts[i]);
687 __connmanctl_dbus_append_dict_entry(iter,
688 ipv6[i], DBUS_TYPE_BYTE,
691 __connmanctl_dbus_append_dict_entry(iter,
692 ipv6[i], DBUS_TYPE_STRING,
700 } else if (g_strcmp0(opts[0], "off") != 0) {
701 fprintf(stderr, "Error %s: %s\n", opts[0], strerror(-EINVAL));
706 __connmanctl_dbus_append_dict_entry(iter, "Method", DBUS_TYPE_STRING,
710 static void config_append_str(DBusMessageIter *iter, void *user_data)
712 struct config_append *append = user_data;
713 char **opts = append->opts;
719 while (opts[i] != NULL) {
720 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
728 static void append_servers(DBusMessageIter *iter, void *user_data)
730 struct config_append *append = user_data;
731 char **opts = append->opts;
737 while (opts[i] != NULL && g_strcmp0(opts[i], "--excludes") != 0) {
738 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
746 static void append_excludes(DBusMessageIter *iter, void *user_data)
748 struct config_append *append = user_data;
749 char **opts = append->opts;
750 int i = append->values;
752 if (opts == NULL || opts[i] == NULL ||
753 g_strcmp0(opts[i], "--excludes") != 0)
757 while (opts[i] != NULL) {
758 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
766 static void config_append_proxy(DBusMessageIter *iter, void *user_data)
768 struct config_append *append = user_data;
769 char **opts = append->opts;
774 if (g_strcmp0(opts[0], "manual") == 0) {
775 __connmanctl_dbus_append_dict_string_array(iter, "Servers",
776 append_servers, append);
778 __connmanctl_dbus_append_dict_string_array(iter, "Excludes",
779 append_excludes, append);
781 } else if (g_strcmp0(opts[0], "auto") == 0) {
782 if (opts[1] != NULL) {
783 __connmanctl_dbus_append_dict_entry(iter, "URL",
784 DBUS_TYPE_STRING, &opts[1]);
788 } else if (g_strcmp0(opts[0], "direct") != 0)
791 __connmanctl_dbus_append_dict_entry(iter, "Method",DBUS_TYPE_STRING,
797 static int cmd_config(char *args[], int num, struct option *options)
799 int result = 0, res = 0, index = 2, oldindex = 0;
801 char *service_name, *path;
804 struct config_append append;
806 service_name = args[1];
807 if (service_name == NULL)
810 while (index < num && args[index] != NULL) {
811 c = parse_args(args[index], options);
812 opt_start = &args[index + 1];
813 append.opts = opt_start;
819 path = g_strdup_printf("/net/connman/service/%s", service_name);
823 switch (parse_boolean(*opt_start)) {
838 res = __connmanctl_dbus_set_property(connection,
839 path, "net.connman.Service",
841 g_strdup(service_name),
843 DBUS_TYPE_BOOLEAN, &val);
847 res = __connmanctl_dbus_set_property_dict(connection,
848 path, "net.connman.Service",
849 config_return, g_strdup(service_name),
850 "IPv4.Configuration", DBUS_TYPE_STRING,
851 config_append_ipv4, &append);
852 index += append.values;
856 res = __connmanctl_dbus_set_property_dict(connection,
857 path, "net.connman.Service",
858 config_return, g_strdup(service_name),
859 "IPv6.Configuration", DBUS_TYPE_STRING,
860 config_append_ipv6, &append);
861 index += append.values;
865 res = __connmanctl_dbus_set_property_array(connection,
866 path, "net.connman.Service",
867 config_return, g_strdup(service_name),
868 "Nameservers.Configuration",
869 DBUS_TYPE_STRING, config_append_str,
871 index += append.values;
875 res = __connmanctl_dbus_set_property_array(connection,
876 path, "net.connman.Service",
877 config_return, g_strdup(service_name),
878 "Timeservers.Configuration",
879 DBUS_TYPE_STRING, config_append_str,
881 index += append.values;
885 res = __connmanctl_dbus_set_property_array(connection,
886 path, "net.connman.Service",
887 config_return, g_strdup(service_name),
888 "Domains.Configuration",
889 DBUS_TYPE_STRING, config_append_str,
891 index += append.values;
895 res = __connmanctl_dbus_set_property_dict(connection,
896 path, "net.connman.Service",
897 config_return, g_strdup(service_name),
898 "Proxy.Configuration",
899 DBUS_TYPE_STRING, config_append_proxy,
901 index += append.values;
904 res = __connmanctl_dbus_method_call(connection,
905 path, "net.connman.Service", "Remove",
906 config_return, g_strdup(service_name),
917 if (res == -EINPROGRESS)
918 result = -EINPROGRESS;
920 printf("Error '%s': %s\n", args[oldindex],
931 static DBusHandlerResult monitor_changed(DBusConnection *connection,
932 DBusMessage *message, void *user_data)
934 DBusMessageIter iter;
935 const char *interface, *path;
937 interface = dbus_message_get_interface(message);
938 if (strncmp(interface, "net.connman.", 12) != 0)
939 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
941 interface = strrchr(interface, '.');
942 if (interface != NULL && *interface != '\0')
945 path = strrchr(dbus_message_get_path(message), '/');
946 if (path != NULL && *path != '\0')
949 __connmanctl_save_rl();
951 if (dbus_message_is_signal(message, "net.connman.Manager",
952 "ServicesChanged") == TRUE) {
954 fprintf(stdout, "%-12s %-20s = {\n", interface,
956 dbus_message_iter_init(message, &iter);
957 __connmanctl_services_list(&iter);
958 fprintf(stdout, "\n}\n");
960 __connmanctl_redraw_rl();
962 return DBUS_HANDLER_RESULT_HANDLED;
965 if (dbus_message_is_signal(message, "net.connman.Manager",
966 "TechnologyAdded") == TRUE)
967 path = "TechnologyAdded";
969 if (dbus_message_is_signal(message, "net.connman.Manager",
970 "TechnologyRemoved") == TRUE)
971 path = "TechnologyRemoved";
973 fprintf(stdout, "%-12s %-20s ", interface, path);
974 dbus_message_iter_init(message, &iter);
976 __connmanctl_dbus_print(&iter, "", " = ", " = ");
977 fprintf(stdout, "\n");
979 __connmanctl_redraw_rl();
981 return DBUS_HANDLER_RESULT_HANDLED;
984 static bool monitor_s = false;
985 static bool monitor_t = false;
986 static bool monitor_m = false;
988 static void monitor_add(char *interface)
993 if (monitor_s == false && monitor_t == false && monitor_m == false)
994 dbus_connection_add_filter(connection, monitor_changed,
997 if (g_strcmp0(interface, "Service") == 0) {
998 if (monitor_s == true)
1001 } else if (g_strcmp0(interface, "Technology") == 0) {
1002 if (monitor_t == true)
1005 } else if (g_strcmp0(interface, "Manager") == 0) {
1006 if (monitor_m == true)
1012 dbus_error_init(&err);
1013 rule = g_strdup_printf("type='signal',interface='net.connman.%s'",
1015 dbus_bus_add_match(connection, rule, &err);
1018 if (dbus_error_is_set(&err))
1019 fprintf(stderr, "Error: %s\n", err.message);
1022 static void monitor_del(char *interface)
1026 if (g_strcmp0(interface, "Service") == 0) {
1027 if (monitor_s == false)
1030 } else if (g_strcmp0(interface, "Technology") == 0) {
1031 if (monitor_t == false)
1034 } else if (g_strcmp0(interface, "Manager") == 0) {
1035 if (monitor_m == false)
1041 rule = g_strdup_printf("type='signal',interface='net.connman.%s'",
1043 dbus_bus_remove_match(connection, rule, NULL);
1046 if (monitor_s == false && monitor_t == false && monitor_m == false)
1047 dbus_connection_remove_filter(connection, monitor_changed,
1051 static int cmd_monitor(char *args[], int num, struct option *options)
1060 switch (parse_boolean(args[2])) {
1070 c = parse_args(args[1], options);
1073 monitor_add("Service");
1074 monitor_add("Technology");
1075 monitor_add("Manager");
1080 monitor_add("Service");
1082 monitor_del("Service");
1087 monitor_add("Technology");
1089 monitor_del("Technology");
1094 monitor_add("Manager");
1096 monitor_del("Manager");
1100 switch(parse_boolean(args[1])) {
1102 monitor_del("Service");
1103 monitor_del("Technology");
1104 monitor_del("Manager");
1108 monitor_add("Service");
1109 monitor_add("Technology");
1110 monitor_add("Manager");
1119 return -EINPROGRESS;
1124 static int cmd_exit(char *args[], int num, struct option *options)
1129 static struct option service_options[] = {
1130 {"properties", required_argument, 0, 'p'},
1134 static const char *service_desc[] = {
1135 "[<service>] (obsolete)",
1139 static struct option config_options[] = {
1140 {"nameservers", required_argument, 0, 'n'},
1141 {"timeservers", required_argument, 0, 't'},
1142 {"domains", required_argument, 0, 'd'},
1143 {"ipv6", required_argument, 0, 'v'},
1144 {"proxy", required_argument, 0, 'x'},
1145 {"autoconnect", required_argument, 0, 'a'},
1146 {"ipv4", required_argument, 0, 'i'},
1147 {"remove", 0, 0, 'r'},
1151 static const char *config_desc[] = {
1152 "<dns1> [<dns2>] [<dns3>]",
1153 "<ntp1> [<ntp2>] [...]",
1154 "<domain1> [<domain2>] [...]",
1155 "off|auto [enable|disable|prefered]|\n"
1156 "\t\t\tmanual <address> <prefixlength> <gateway>",
1157 "direct|auto <URL>|manual <URL1> [<URL2>] [...]\n"
1158 "\t\t\t[exclude <exclude1> [<exclude2>] [...]]",
1160 "off|dhcp|manual <address> <netmask> <gateway>",
1165 static struct option monitor_options[] = {
1166 {"services", no_argument, 0, 's'},
1167 {"tech", no_argument, 0, 'c'},
1168 {"manager", no_argument, 0, 'm'},
1172 static const char *monitor_desc[] = {
1173 "[off] Monitor only services",
1174 "[off] Monitor only technologies",
1175 "[off] Monitor only manager interface",
1179 static const struct {
1181 const char *argument;
1182 struct option *options;
1183 const char **options_desc;
1184 int (*func) (char *args[], int num, struct option *options);
1187 { "enable", "<technology>|offline", NULL, NULL,
1188 cmd_enable, "Enables given technology or offline mode" },
1189 { "disable", "<technology>|offline", NULL, NULL,
1190 cmd_disable, "Disables given technology or offline mode"},
1191 { "state", NULL, NULL, NULL,
1192 cmd_state, "Shows if the system is online or offline" },
1193 { "tether", "<technology> on|off\n"
1194 " wifi [on|off] <ssid> <passphrase> ",
1197 "Enable, disable tethering, set SSID and passphrase for wifi" },
1198 { "services", "[<service>]", service_options, &service_desc[0],
1199 cmd_services, "Display services" },
1200 { "technologies", NULL, NULL, NULL,
1201 cmd_technologies, "Display technologies" },
1202 { "scan", "<technology>", NULL, NULL,
1203 cmd_scan, "Scans for new services for given technology" },
1204 { "connect", "<service>", NULL, NULL,
1205 cmd_connect, "Connect a given service" },
1206 { "disconnect", "<service>", NULL, NULL,
1207 cmd_disconnect, "Disconnect a given service" },
1208 { "config", "<service>", config_options, &config_desc[0],
1209 cmd_config, "Set service configuration options" },
1210 { "monitor", "[off]", monitor_options, &monitor_desc[0],
1211 cmd_monitor, "Monitor signals from interfaces" },
1212 { "help", NULL, NULL, NULL,
1213 cmd_help, "Show help" },
1214 { "exit", NULL, NULL, NULL,
1216 { "quit", NULL, NULL, NULL,
1221 static int cmd_help(char *args[], int num, struct option *options)
1223 bool interactive = __connmanctl_is_interactive();
1226 if (interactive == false)
1227 fprintf(stdout, "Usage: connmanctl [[command] [args]]\n");
1229 for (i = 0; cmd_table[i].cmd != NULL; i++) {
1230 const char *cmd = cmd_table[i].cmd;
1231 const char *argument = cmd_table[i].argument;
1232 const char *desc = cmd_table[i].desc;
1234 printf("%-12s%-22s%s\n", cmd != NULL? cmd: "",
1235 argument != NULL? argument: "",
1236 desc != NULL? desc: "");
1238 if (cmd_table[i].options != NULL) {
1239 for (j = 0; cmd_table[i].options[j].name != NULL;
1241 const char *options_desc =
1242 cmd_table[i].options_desc != NULL ?
1243 cmd_table[i].options_desc[j]: "";
1245 printf(" --%-12s%s\n",
1246 cmd_table[i].options[j].name,
1252 if (interactive == false)
1253 fprintf(stdout, "\nNote: arguments and output are considered "
1254 "EXPERIMENTAL for now.\n");
1259 int __connmanctl_commands(DBusConnection *dbus_conn, char *argv[], int argc)
1263 connection = dbus_conn;
1265 for (i = 0; cmd_table[i].cmd != NULL; i++) {
1266 if (g_strcmp0(cmd_table[i].cmd, argv[0]) == 0 &&
1267 cmd_table[i].func != NULL) {
1268 result = cmd_table[i].func(argv, argc,
1269 cmd_table[i].options);
1270 if (result < 0 && result != -EINPROGRESS)
1271 fprintf(stderr, "Error '%s': %s\n", argv[0],
1277 fprintf(stderr, "Error '%s': Unknown command\n", argv[0]);
1281 char *__connmanctl_lookup_command(const char *text, int state)
1291 while (cmd_table[i].cmd != NULL) {
1292 const char *command = cmd_table[i].cmd;
1296 if (strncmp(text, command, len) == 0)
1297 return strdup(command);