client/input.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2012-2014  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 <stdlib.h>
  29 #include <errno.h>
  30 #include <glib.h>
  31 #include <readline/readline.h>
  32 #include <readline/history.h>
  33
  34 #include <gdbus.h>
  35 #include "input.h"
  36 #include "commands.h"
  37
  38 static DBusConnection *connection;
  39 static GMainLoop *main_loop;
  40 static bool interactive = false;
  41
  42 static bool save_input;
  43 static char *saved_line;
  44 static int saved_point;
  45
  46 void __connmanctl_quit(void)
  47 {
  48         if (main_loop)
  49                 g_main_loop_quit(main_loop);
  50 }
  51
  52 bool __connmanctl_is_interactive(void)
  53 {
  54         return interactive;
  55 }
  56
  57 void __connmanctl_save_rl(void)
  58 {
  59         save_input = !RL_ISSTATE(RL_STATE_DONE);
  60
  61         if (save_input) {
  62                 saved_point = rl_point;
  63                 saved_line = rl_copy_text(0, rl_end);
  64                 rl_save_prompt();
  65                 rl_replace_line("", 0);
  66                 rl_redisplay();
  67         }
  68 }
  69
  70 void __connmanctl_redraw_rl(void)
  71 {
  72         if (save_input) {
  73                 rl_restore_prompt();
  74                 rl_replace_line(saved_line, 0);
  75                 rl_point = saved_point;
  76                 rl_redisplay();
  77                 free(saved_line);
  78         }
  79
  80         save_input = 0;
  81 }
  82
  83 static void rl_handler(char *input)
  84 {
  85         char **args, **trim_args;
  86         int num, len, err, i;
  87
  88         if (!input) {
  89                 rl_newline(1, '\n');
  90                 g_main_loop_quit(main_loop);
  91                 return;
  92         }
  93
  94         args = g_strsplit(input, " ", 0);
  95         num = g_strv_length(args);
  96
  97         trim_args = g_new0(char *, num + 1);
  98         for (i = 0, len = 0; i < num; i++) {
  99                 if (*args[i] != '\0') {
 100                         trim_args[len] = args[i];
 101                         len++;
 102                 }
 103         }
 104
 105         if (len > 0) {
 106                 HIST_ENTRY *previous = history_get(where_history());
 107                 if(!previous || strcmp(previous->line, input))
 108                         add_history(input);
 109
 110                 err = __connmanctl_commands(connection, trim_args, len);
 111
 112                 if (err > 0)
 113                         g_main_loop_quit(main_loop);
 114         }
 115
 116         g_strfreev(args);
 117         g_free(trim_args);
 118         free(input);
 119 }
 120
 121 static gboolean input_handler(GIOChannel *channel, GIOCondition condition,
 122                 gpointer user_data)
 123 {
 124         if (condition & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
 125                 g_main_loop_quit(main_loop);
 126                 return FALSE;
 127         }
 128
 129         rl_callback_read_char();
 130         return TRUE;
 131 }
 132
 133 static char **complete_agent(const char *text, int start, int end)
 134 {
 135         rl_attempted_completion_over = 1;
 136
 137         return NULL;
 138 }
 139
 140 /* Return how many parameters we have typed */
 141 int __connmanctl_input_calc_level(void)
 142 {
 143         int count = 0;
 144         char *ptr;
 145
 146         ptr = rl_line_buffer;
 147
 148         while (*ptr) {
 149                 if (*ptr == ' ') {
 150                         if (*(ptr + 1) == ' ') {
 151                                 ptr++;
 152                                 continue;
 153                         } else
 154                                 count++;
 155                 }
 156                 ptr++;
 157         }
 158
 159         return count;
 160 }
 161
 162 void __connmanctl_input_lookup_end(void)
 163 {
 164         rl_attempted_completion_over = 1;
 165 }
 166
 167 static char **complete_command(const char *text, int start, int end)
 168 {
 169         if (start == 0) {
 170                 return rl_completion_matches(text,
 171                                 __connmanctl_lookup_command);
 172
 173         } else {
 174                 __connmanctl_lookup_cb cb;
 175                 char **str = NULL;
 176
 177                 cb = __connmanctl_get_lookup_func(rl_line_buffer);
 178                 if (cb)
 179                         str = rl_completion_matches(text, cb);
 180                 else
 181                         rl_attempted_completion_over = 1;
 182
 183                 return str;
 184         }
 185 }
 186
 187 static struct {
 188         connmanctl_input_func_t cb;
 189         void *user_data;
 190 } agent_handler;
 191
 192 static void rl_agent_handler(char *input)
 193 {
 194         agent_handler.cb(input, agent_handler.user_data);
 195 }
 196
 197 void __connmanctl_agent_mode(const char *prompt,
 198                 connmanctl_input_func_t input_handler, void *user_data)
 199 {
 200         agent_handler.cb = input_handler;
 201         agent_handler.user_data = user_data;
 202
 203         if (input_handler)
 204                 rl_callback_handler_install(prompt, rl_agent_handler);
 205         else {
 206                 rl_set_prompt(prompt);
 207                 rl_callback_handler_remove();
 208                 rl_redisplay();
 209         }
 210         rl_attempted_completion_function = complete_agent;
 211 }
 212
 213 void __connmanctl_command_mode(void)
 214 {
 215         rl_callback_handler_install("connmanctl> ", rl_handler);
 216         rl_attempted_completion_function = complete_command;
 217 }
 218
 219 int __connmanctl_input_init(int argc, char *argv[])
 220 {
 221         char *help[] = {
 222                 "help",
 223                 NULL
 224         };
 225         guint source = 0;
 226         int err;
 227         DBusError dbus_err;
 228         GIOChannel *channel;
 229
 230         dbus_error_init(&dbus_err);
 231         connection = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &dbus_err);
 232
 233         if (dbus_error_is_set(&dbus_err)) {
 234                 fprintf(stderr, "Error: %s\n", dbus_err.message);
 235                 dbus_error_free(&dbus_err);
 236                 return 1;
 237         }
 238
 239         if (argc < 2) {
 240                 interactive = true;
 241
 242                 channel = g_io_channel_unix_new(fileno(stdin));
 243                 source = g_io_add_watch(channel,
 244                                 G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL,
 245                                 input_handler, NULL);
 246                 g_io_channel_unref(channel);
 247
 248                 __connmanctl_monitor_completions(connection);
 249
 250                 __connmanctl_command_mode();
 251
 252                 err = -EINPROGRESS;
 253         } else {
 254                 interactive = false;
 255
 256                 if (strcmp(argv[1], "--help") == 0 ||
 257                                 strcmp(argv[1], "-h") == 0)
 258                         err = __connmanctl_commands(connection, help, 1);
 259                 else
 260                         err = __connmanctl_commands(connection, argv + 1,
 261                                         argc - 1);
 262         }
 263
 264         if (err == -EINPROGRESS) {
 265                 main_loop = g_main_loop_new(NULL, FALSE);
 266                 g_main_loop_run(main_loop);
 267
 268                 err = 0;
 269         }
 270
 271         if (interactive) {
 272                 g_source_remove(source);
 273                 __connmanctl_monitor_completions(NULL);
 274
 275                 rl_callback_handler_remove();
 276 #if !defined TIZEN_EXT
 277                 rl_message("");
 278 #endif
 279         }
 280
 281         dbus_connection_unref(connection);
 282         if (main_loop)
 283                 g_main_loop_unref(main_loop);
 284
 285         if (err < 0)
 286                 err = -err;
 287         else
 288                 err = 0;
 289
 290         return err;
 291 }