source4/torture/shell.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB torture tester
   4    Copyright (C) Andrew Tridgell 1997-2003
   5    Copyright (C) Jelmer Vernooij 2006-2008
   6    Copyright (C) James Peach 2010
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "system/readline.h"
  24 #include "../libcli/smbreadline/smbreadline.h"
  25 #include "lib/cmdline/popt_common.h"
  26 #include "auth/credentials/credentials.h"
  27 #include "torture/smbtorture.h"
  28 #include "param/param.h"
  29
  30 struct shell_command;
  31
  32 typedef void (*shell_function)(const struct shell_command *,
  33         struct torture_context *, int, const char **);
  34
  35 static void shell_quit(const struct shell_command *,
  36         struct torture_context *, int, const char **);
  37 static void shell_help(const struct shell_command *,
  38         struct torture_context *, int, const char **);
  39 static void shell_set(const struct shell_command *,
  40         struct torture_context *, int, const char **);
  41 static void shell_run(const struct shell_command *,
  42         struct torture_context *, int, const char **);
  43 static void shell_list(const struct shell_command *,
  44         struct torture_context *, int, const char **);
  45 static void shell_auth(const struct shell_command *,
  46         struct torture_context *, int, const char **);
  47 static void shell_target(const struct shell_command *,
  48         struct torture_context *, int, const char **);
  49
  50 static void shell_usage(const struct shell_command *);
  51 static bool match_command(const char *, const struct shell_command *);
  52
  53 struct shell_command
  54 {
  55     shell_function  handler;
  56     const char *    name;
  57     const char *    usage;
  58     const char *    help;
  59 } shell_command;
  60
  61 static const struct shell_command commands[] =
  62 {
  63     {
  64         shell_auth, "auth",
  65         "[[username | principal | domain | realm | password] STRING]",
  66         "set authentication parameters"
  67     },
  68
  69     {
  70         shell_help, "help", NULL,
  71         "print this help message"
  72     },
  73
  74     {
  75         shell_list, "list", NULL,
  76         "list the available tests"
  77     },
  78
  79     {
  80         shell_quit, "quit", NULL,
  81         "exit smbtorture"
  82     },
  83
  84     {
  85         shell_run, "run", "[TESTNAME]",
  86         "run the specified test"
  87     },
  88
  89     {
  90         shell_set, "set", "[NAME VALUE]",
  91         "print or set test configuration parameters"
  92     },
  93
  94     {
  95         shell_target, "target", "[TARGET]",
  96         "print or set the test target"
  97     }
  98
  99 };
 100
 101 void torture_shell(struct torture_context *tctx)
 102 {
 103         char *cline;
 104         int argc;
 105         const char **argv;
 106         int ret;
 107         int i;
 108
 109         /* If we don't have a specified password, specify it as empty. This
 110          * stops the credentials system prompting when we use the "auth"
 111          * command to display the current auth parameters.
 112          */
 113         cli_credentials_set_password(cmdline_credentials, "", CRED_GUESS_ENV);
 114
 115         while (1) {
 116                 cline = smb_readline("torture> ", NULL, NULL);
 117
 118                 if (cline == NULL)
 119                         return;
 120
 121 #if HAVE_ADD_HISTORY
 122                 add_history(cline);
 123 #endif
 124
 125                 ret = poptParseArgvString(cline, &argc, &argv);
 126                 if (ret != 0) {
 127                         fprintf(stderr, "Error parsing line\n");
 128                         continue;
 129                 }
 130
 131                 for (i = 0; i < ARRAY_SIZE(commands); i++) {
 132                         if (match_command(argv[0], &commands[i])) {
 133                                 argc--;
 134                                 argv++;
 135                                 commands[i].handler(&commands[i],
 136                                         tctx, argc, argv);
 137                                 break;
 138                         }
 139                 }
 140
 141                 free(cline);
 142         }
 143 }
 144
 145 static void shell_quit(const struct shell_command * command,
 146         struct torture_context *tctx, int argc, const char **argv)
 147 {
 148     exit(0);
 149 }
 150
 151 static void shell_help(const struct shell_command * command,
 152         struct torture_context *tctx, int argc, const char **argv)
 153 {
 154     int i;
 155
 156     if (argc == 1) {
 157             for (i = 0; i < ARRAY_SIZE(commands); i++) {
 158                     if (match_command(argv[0], &commands[i])) {
 159                             shell_usage(&commands[i]);
 160                             return;
 161                     }
 162             }
 163     } else {
 164             fprintf(stdout, "Available commands:\n");
 165             for (i = 0; i < ARRAY_SIZE(commands); i++) {
 166                     fprintf(stdout, "\t%s - %s\n",
 167                             commands[i].name, commands[i].help);
 168             }
 169     }
 170 }
 171
 172 static void shell_set(const struct shell_command *command,
 173         struct torture_context *tctx, int argc, const char **argv)
 174 {
 175         switch (argc) {
 176         case 0:
 177             lpcfg_dump(tctx->lp_ctx, stdout,
 178                     false /* show_defaults */,
 179                     0 /* skip services */);
 180             break;
 181
 182         case 2:
 183             /* We want to allow users to set any config option. Top level
 184              * options will get checked against their static definition, but
 185              * parametric options can't be checked and will just get stashed
 186              * as they are provided.
 187              */
 188             lpcfg_set_cmdline(tctx->lp_ctx, argv[0], argv[1]);
 189             break;
 190
 191         default:
 192             shell_usage(command);
 193         }
 194 }
 195
 196 static void shell_run(const struct shell_command * command,
 197         struct torture_context *tctx, int argc, const char **argv)
 198 {
 199     if (argc != 1) {
 200         shell_usage(command);
 201         return;
 202     }
 203
 204     torture_run_named_tests(tctx, argv[0], NULL /* restricted */);
 205 }
 206
 207 static void shell_list(const struct shell_command * command,
 208         struct torture_context *tctx, int argc, const char **argv)
 209 {
 210     if (argc != 0) {
 211         shell_usage(command);
 212         return;
 213     }
 214
 215     torture_print_testsuites(true);
 216 }
 217
 218 static void shell_auth(const struct shell_command * command,
 219         struct torture_context *tctx, int argc, const char **argv)
 220 {
 221
 222     if (argc == 0) {
 223             const char * username;
 224             const char * domain;
 225             const char * realm;
 226             const char * password;
 227             const char * principal;
 228
 229             username = cli_credentials_get_username(cmdline_credentials);
 230             principal = cli_credentials_get_principal(cmdline_credentials, tctx);
 231             domain = cli_credentials_get_domain(cmdline_credentials);
 232             realm = cli_credentials_get_realm(cmdline_credentials);
 233             password = cli_credentials_get_password(cmdline_credentials);
 234
 235             printf("Username: %s\n", username ? username : "");
 236             printf("User Principal: %s\n", principal ? principal : "");
 237             printf("Domain: %s\n", domain ? domain : "");
 238             printf("Realm: %s\n", realm ? realm : "");
 239             printf("Password: %s\n", password ? password : "");
 240     } else if (argc == 2) {
 241             bool result;
 242
 243             if (!strcmp(argv[0], "username")) {
 244                     result = cli_credentials_set_username(
 245                         cmdline_credentials, argv[1], CRED_SPECIFIED);
 246             } else if (!strcmp(argv[0], "principal")) {
 247                     result = cli_credentials_set_principal(
 248                         cmdline_credentials, argv[1], CRED_SPECIFIED);
 249             } else if (!strcmp(argv[0], "domain")) {
 250                     result = cli_credentials_set_domain(
 251                         cmdline_credentials, argv[1], CRED_SPECIFIED);
 252             } else if (!strcmp(argv[0], "realm")) {
 253                     result = cli_credentials_set_realm(
 254                         cmdline_credentials, argv[1], CRED_SPECIFIED);
 255             } else if (!strcmp(argv[0], "password")) {
 256                     result = cli_credentials_set_password(
 257                         cmdline_credentials, argv[1], CRED_SPECIFIED);
 258             } else {
 259                     shell_usage(command);
 260                     return;
 261             }
 262
 263             if (!result) {
 264                     printf("failed to set %s\n", argv[0]);
 265             }
 266     } else {
 267             shell_usage(command);
 268     }
 269
 270 }
 271
 272 static void shell_target(const struct shell_command *command,
 273         struct torture_context *tctx, int argc, const char **argv)
 274 {
 275         if (argc == 0) {
 276                 const char * host;
 277                 const char * share;
 278                 const char * binding;
 279
 280                 host = torture_setting_string(tctx, "host", NULL);
 281                 share = torture_setting_string(tctx, "share", NULL);
 282                 binding = torture_setting_string(tctx, "binding", NULL);
 283
 284                 printf("Target host: %s\n", host ? host : "");
 285                 printf("Target share: %s\n", share ? share : "");
 286                 printf("Target binding: %s\n", binding ? binding : "");
 287         } else if (argc == 1) {
 288                 torture_parse_target(tctx->lp_ctx, argv[0]);
 289         } else {
 290                 shell_usage(command);
 291         }
 292 }
 293
 294 static void shell_usage(const struct shell_command * command)
 295 {
 296     if (command->usage) {
 297             fprintf(stderr, "Usage: %s %s\n",
 298                     command->name, command->usage);
 299     } else {
 300             fprintf(stderr, "Usage: %s\n",
 301                     command->name);
 302     }
 303 }
 304
 305 static bool match_command(const char * name,
 306         const struct shell_command * command)
 307 {
 308         if (!strcmp(name, command->name)) {
 309                 return true;
 310         }
 311
 312         if (name[0] == command->name[0] && name[1] == '\0') {
 313             return true;
 314         }
 315
 316         return false;
 317 }