SecurityTool/sharedTool/SecurityTool.c

   1 /*
   2  * Copyright (c) 2003-2010,2013-2017 Apple Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  *
  23  * security.c
  24  */
  25
  26 #include "SecurityTool.h"
  27 #include "SecInternalReleasePriv.h"
  28
  29 #include "SecurityTool/sharedTool/readline.h"
  30 #include "SecurityTool/sharedTool/security_tool_commands.h"
  31
  32 #include "leaks.h"
  33
  34 #include <ctype.h>
  35 #include <err.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40
  41 #include <CoreFoundation/CFRunLoop.h>
  42
  43 #if NO_SERVER
  44 #include <securityd/spi.h>
  45 #endif
  46
  47 /* Maximum length of an input line in interactive mode. */
  48 #define MAX_LINE_LEN 4096
  49 /* Maximum number of arguments on an input line in interactive mode. */
  50 #define MAX_ARGS 32
  51
  52
  53 /* The default prompt. */
  54 const char *prompt_string = "security> ";
  55
  56 /* Forward declarations of static functions. */
  57
  58
  59 /* Global variables. */
  60 int do_quiet = 0;
  61 int do_verbose = 0;
  62
  63 /* Return 1 if name matches command. */
  64 static int
  65 match_command(const char *command_name, const char *name)
  66 {
  67         return !strncmp(command_name, name, strlen(name));
  68 }
  69
  70 /* The help command. */
  71 int
  72 help(int argc, char * const *argv)
  73 {
  74         const command *c;
  75
  76         if (argc > 1)
  77         {
  78                 char * const *arg;
  79                 for (arg = argv + 1; *arg; ++arg)
  80                 {
  81                         int found = 0;
  82
  83                         for (c = commands; c->c_name; ++c)
  84                         {
  85                                 if (match_command(c->c_name, *arg))
  86                                 {
  87                                         found = 1;
  88                                         break;
  89                                 }
  90                         }
  91
  92                         if (found)
  93                                 printf("Usage: %s %s\n", c->c_name, c->c_usage);
  94                         else
  95                         {
  96                                 fprintf(stderr, "%s: no such command: %s", argv[0], *arg);
  97                                 return 1;
  98                         }
  99                 }
 100         }
 101         else
 102         {
 103                 for (c = commands; c->c_name; ++c)
 104                         printf("    %-17s %s\n", c->c_name, c->c_help);
 105         }
 106
 107         return 0;
 108 }
 109
 110 /* States for split_line parser. */
 111 typedef enum
 112 {
 113         SKIP_WS,
 114         READ_ARG,
 115         READ_ARG_ESCAPED,
 116         QUOTED_ARG,
 117         QUOTED_ARG_ESCAPED
 118 } parse_state;
 119
 120 /* Split a line into multiple arguments and return them in *pargc and *pargv. */
 121 static void
 122 split_line(char *line, int *pargc, char * const **pargv)
 123 {
 124         static char *argvec[MAX_ARGS + 1];
 125         int argc = 0;
 126         char *ptr = line;
 127         char *dst = line;
 128         parse_state state = SKIP_WS;
 129         int quote_ch = 0;
 130
 131         for (ptr = line; *ptr; ++ptr)
 132         {
 133                 if (state == SKIP_WS)
 134                 {
 135                         if (isspace(*ptr))
 136                                 continue;
 137
 138                         if (*ptr == '"' || *ptr == '\'')
 139                         {
 140                                 quote_ch = *ptr;
 141                                 state = QUOTED_ARG;
 142                                 argvec[argc] = dst;
 143                                 continue; /* Skip the quote. */
 144                         }
 145                         else
 146                         {
 147                                 state = READ_ARG;
 148                                 argvec[argc] = dst;
 149                         }
 150                 }
 151
 152                 if (state == READ_ARG)
 153                 {
 154                         if (*ptr == '\\')
 155                         {
 156                                 state = READ_ARG_ESCAPED;
 157                                 continue;
 158                         }
 159                         else if (isspace(*ptr))
 160                         {
 161                                 /* 0 terminate each arg. */
 162                                 *dst++ = '\0';
 163                                 argc++;
 164                                 state = SKIP_WS;
 165                                 if (argc >= MAX_ARGS)
 166                                         break;
 167                         }
 168                         else
 169                                 *dst++ = *ptr;
 170                 }
 171
 172                 if (state == QUOTED_ARG)
 173                 {
 174                         if (*ptr == '\\')
 175                         {
 176                                 state = QUOTED_ARG_ESCAPED;
 177                                 continue;
 178                         }
 179                         if (*ptr == quote_ch)
 180                         {
 181                                 /* 0 terminate each arg. */
 182                                 *dst++ = '\0';
 183                                 argc++;
 184                                 state = SKIP_WS;
 185                                 if (argc >= MAX_ARGS)
 186                                         break;
 187                         }
 188                         else
 189                                 *dst++ = *ptr;
 190                 }
 191
 192                 if (state == READ_ARG_ESCAPED)
 193                 {
 194                         *dst++ = *ptr;
 195                         state = READ_ARG;
 196                 }
 197
 198                 if (state == QUOTED_ARG_ESCAPED)
 199                 {
 200                         *dst++ = *ptr;
 201                         state = QUOTED_ARG;
 202                 }
 203         }
 204
 205         if (state != SKIP_WS)
 206         {
 207                 /* Terminate last arg. */
 208                 *dst++ = '\0';
 209                 argc++;
 210         }
 211
 212         /* Teminate arg vector. */
 213         argvec[argc] = NULL;
 214
 215         *pargv = argvec;
 216         *pargc = argc;
 217 }
 218
 219 /* Print a (hopefully) useful usage message. */
 220 static int
 221 usage(void)
 222 {
 223         printf(
 224                 "Usage: %s [-h] [-i] [-l] [-p prompt] [-q] [-v] [command] [opt ...]\n"
 225                 "    -i    Run in interactive mode.\n"
 226                 "    -l    Run /usr/bin/leaks -nocontext before exiting.\n"
 227                 "    -p    Set the prompt to \"prompt\" (implies -i).\n"
 228                 "    -q    Be less verbose.\n"
 229                 "    -v    Be more verbose about what's going on.\n"
 230                 "%s commands are:\n", getprogname(), getprogname());
 231         help(0, NULL);
 232         return SHOW_USAGE_MESSAGE;
 233 }
 234
 235 /* Execute a single command. */
 236 static int
 237 execute_command(int argc, char * const *argv)
 238 {
 239         const command *c;
 240         int found = 0;
 241
 242         /* Nothing to do. */
 243         if (argc == 0)
 244                 return 0;
 245
 246         for (c = commands; c->c_name; ++c)
 247         {
 248                 if (match_command(c->c_name, argv[0]))
 249                 {
 250                         found = 1;
 251                         break;
 252                 }
 253         }
 254
 255         if (found)
 256         {
 257                 int result;
 258
 259                 /* Reset getopt for command proc. */
 260                 optind = 1;
 261                 optreset = 1;
 262
 263                 if (do_verbose)
 264                 {
 265                         int ix;
 266
 267                         fprintf(stderr, "%s", c->c_name);
 268                         for (ix = 1; ix < argc; ++ix)
 269                                 fprintf(stderr, " \"%s\"", argv[ix]);
 270                         fprintf(stderr, "\n");
 271                 }
 272
 273                 result = c->c_func(argc, argv);
 274                 if (result == 2)
 275                         fprintf(stderr, "Usage: %s %s\n        %s\n", c->c_name, c->c_usage, c->c_help);
 276
 277                 return result;
 278         }
 279         else
 280         {
 281                 warnx("unknown command: %s", argv[0]);
 282                 return 1;
 283         }
 284 }
 285
 286 static void
 287 receive_notifications(void)
 288 {
 289         /* Run the CFRunloop to get any pending notifications. */
 290         while (CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.0, TRUE) == kCFRunLoopRunHandledSource);
 291 }
 292
 293 int
 294 main(int argc, char * const *argv)
 295 {
 296         int result = 0;
 297         int do_help = 0;
 298         int do_interactive = 0;
 299         int do_leaks = 0;
 300         int ch;
 301
 302         if (!SecIsInternalRelease()) {
 303                 errx(1, "command unavailable");
 304         }
 305
 306         /* Do getopt stuff for global options. */
 307         optind = 1;
 308         optreset = 1;
 309         while ((ch = getopt(argc, argv, "hilp:qv")) != -1)
 310         {
 311                 switch  (ch)
 312                 {
 313                 case 'h':
 314                         do_help = 1;
 315                         break;
 316                 case 'i':
 317                         do_interactive = 1;
 318                         break;
 319                 case 'l':
 320                         do_leaks = 1;
 321                         break;
 322                 case 'p':
 323                         do_interactive = 1;
 324                         prompt_string = optarg;
 325                         break;
 326                 case 'q':
 327                         do_quiet = 1;
 328                         break;
 329                 case 'v':
 330                         do_verbose = 1;
 331                         break;
 332                 case '?':
 333                 default:
 334                         return usage();
 335                 }
 336         }
 337
 338         argc -= optind;
 339         argv += optind;
 340
 341 #if NO_SERVER
 342 # if DEBUG
 343 //    securityd_init();
 344 # endif
 345 #endif
 346
 347         if (do_help)
 348         {
 349                 /* Munge argc/argv so that argv[0] is something. */
 350                 return help(argc + 1, argv - 1);
 351         }
 352         else if (argc > 0)
 353         {
 354                 receive_notifications();
 355                 result = execute_command(argc, argv);
 356                 receive_notifications();
 357         }
 358         else if (do_interactive)
 359         {
 360                 /* In interactive mode we just read commands and run them until readline returns NULL. */
 361
 362         /* Only show prompt string if stdin is a tty. */
 363         int show_prompt = isatty(0);
 364
 365                 for (;;)
 366                 {
 367                         static char buffer[MAX_LINE_LEN];
 368                         char * const *av, *input;
 369                         int ac;
 370
 371             if (show_prompt)
 372                 fprintf(stderr, "%s", prompt_string);
 373
 374                         input = readline(buffer, MAX_LINE_LEN);
 375                         if (!input)
 376                                 break;
 377
 378                         split_line(input, &ac, &av);
 379                         receive_notifications();
 380                         result = execute_command(ac, av);
 381                         receive_notifications();
 382                         if (result == -1)
 383                         {
 384                                 result = 0;
 385                                 break;
 386                         }
 387
 388                         if (result && ! do_quiet)
 389                         {
 390                                 fprintf(stderr, "%s: returned %d\n", av[0], result);
 391                         }
 392                 }
 393         }
 394         else
 395                 result = usage();
 396
 397         if (do_leaks)
 398         {
 399                 char *const argvec[3] = { "leaks", "-nocontext", NULL };
 400                 leaks(2, argvec);
 401         }
 402
 403         return result;
 404 }