2 * e4crypt.c - ext4 encryption management utility
4 * Copyright (c) 2014 Google, Inc.
5 * SHA512 implementation from libtomcrypt.
7 * Authors: Michael Halcrow <mhalcrow@google.com>,
8 * Ildar Muslukhov <ildarm@google.com>
11 #ifndef _LARGEFILE_SOURCE
12 #define _LARGEFILE_SOURCE
15 #ifndef _LARGEFILE64_SOURCE
16 #define _LARGEFILE64_SOURCE
35 #include <sys/ioctl.h>
37 #include <sys/types.h>
42 #if !defined(HAVE_ADD_KEY) || !defined(HAVE_KEYCTL)
43 #include <sys/syscall.h>
49 #include "ext2fs/ext2_fs.h"
50 #include "ext2fs/ext2fs.h"
51 #include "uuid/uuid.h"
53 /* special process keyring shortcut IDs */
54 #define KEY_SPEC_THREAD_KEYRING -1
55 #define KEY_SPEC_PROCESS_KEYRING -2
56 #define KEY_SPEC_SESSION_KEYRING -3
57 #define KEY_SPEC_USER_KEYRING -4
58 #define KEY_SPEC_USER_SESSION_KEYRING -5
59 #define KEY_SPEC_GROUP_KEYRING -6
61 #define KEYCTL_GET_KEYRING_ID 0
62 #define KEYCTL_JOIN_SESSION_KEYRING 1
63 #define KEYCTL_DESCRIBE 6
64 #define KEYCTL_SEARCH 10
65 #define KEYCTL_SESSION_TO_PARENT 18
67 typedef __s32 key_serial_t;
69 #define EXT4_KEY_REF_STR_BUF_SIZE ((EXT4_KEY_DESCRIPTOR_SIZE * 2) + 1)
71 #ifndef EXT4_IOC_GET_ENCRYPTION_PWSALT
72 #define EXT4_IOC_GET_ENCRYPTION_PWSALT _IOW('f', 20, __u8[16])
75 #define OPT_VERBOSE 0x0001
76 #define OPT_QUIET 0x0002
81 static long keyctl(int cmd, ...)
84 unsigned long arg2, arg3, arg4, arg5;
87 arg2 = va_arg(va, unsigned long);
88 arg3 = va_arg(va, unsigned long);
89 arg4 = va_arg(va, unsigned long);
90 arg5 = va_arg(va, unsigned long);
92 return syscall(__NR_keyctl, cmd, arg2, arg3, arg4, arg5);
97 static key_serial_t add_key(const char *type, const char *description,
98 const void *payload, size_t plen,
101 return syscall(__NR_add_key, type, description, payload,
106 static const unsigned char *hexchars = (const unsigned char *) "0123456789abcdef";
107 static const size_t hexchars_size = 16;
109 #define SHA512_LENGTH 64
110 #define EXT2FS_KEY_TYPE_LOGON "logon"
111 #define EXT2FS_KEY_DESC_PREFIX "ext4:"
112 #define EXT2FS_KEY_DESC_PREFIX_SIZE 5
114 #define EXT4_IOC_SET_ENCRYPTION_POLICY _IOR('f', 19, struct ext4_encryption_policy)
115 #define EXT4_IOC_GET_ENCRYPTION_POLICY _IOW('f', 21, struct ext4_encryption_policy)
117 static void validate_paths(int argc, char *argv[], int path_start_index)
123 for (x = path_start_index; x < argc; x++) {
124 int ret = access(argv[x], W_OK);
131 ret = stat(argv[x], &st);
134 if (!S_ISDIR(st.st_mode)) {
135 fprintf(stderr, "%s is not a directory\n", argv[x]);
143 static int hex2byte(const char *hex, size_t hex_size, unsigned char *bytes,
147 unsigned char *h, *l;
151 for (x = 0; x < hex_size; x += 2) {
152 h = memchr(hexchars, hex[x], hexchars_size);
155 l = memchr(hexchars, hex[x + 1], hexchars_size);
158 if ((x >> 1) >= bytes_size)
160 bytes[x >> 1] = (((unsigned char)(h - hexchars) << 4) +
161 (unsigned char)(l - hexchars));
171 char key_ref_str[EXT4_KEY_REF_STR_BUF_SIZE];
172 unsigned char key_desc[EXT4_KEY_DESCRIPTOR_SIZE];
173 unsigned char key[EXT4_MAX_KEY_SIZE];
176 struct salt *salt_list;
179 char in_passphrase[EXT4_MAX_PASSPHRASE_SIZE];
181 static struct salt *find_by_salt(unsigned char *salt, size_t salt_len)
186 for (i = 0, p = salt_list; i < num_salt; i++, p++)
187 if ((p->salt_len == salt_len) &&
188 !memcmp(p->salt, salt, salt_len))
193 static void add_salt(unsigned char *salt, size_t salt_len)
195 if (find_by_salt(salt, salt_len))
197 if (num_salt >= max_salt) {
198 max_salt = num_salt + 10;
199 salt_list = realloc(salt_list, max_salt * sizeof(struct salt));
201 fprintf(stderr, "Couldn't allocate salt list\n");
205 salt_list[num_salt].salt = salt;
206 salt_list[num_salt].salt_len = salt_len;
210 static void clear_secrets(void)
213 memset(salt_list, 0, sizeof(struct salt) * max_salt);
217 memset(in_passphrase, 0, sizeof(in_passphrase));
220 static void die_signal_handler(int signum EXT2FS_ATTR((unused)),
221 siginfo_t *siginfo EXT2FS_ATTR((unused)),
222 void *context EXT2FS_ATTR((unused)))
228 static void sigcatcher_setup(void)
232 memset(&sa, 0, sizeof(struct sigaction));
233 sa.sa_sigaction = die_signal_handler;
234 sa.sa_flags = SA_SIGINFO;
236 sigaction(SIGHUP, &sa, 0);
237 sigaction(SIGINT, &sa, 0);
238 sigaction(SIGQUIT, &sa, 0);
239 sigaction(SIGFPE, &sa, 0);
240 sigaction(SIGILL, &sa, 0);
241 sigaction(SIGBUS, &sa, 0);
242 sigaction(SIGSEGV, &sa, 0);
243 sigaction(SIGABRT, &sa, 0);
244 sigaction(SIGPIPE, &sa, 0);
245 sigaction(SIGALRM, &sa, 0);
246 sigaction(SIGTERM, &sa, 0);
247 sigaction(SIGUSR1, &sa, 0);
248 sigaction(SIGUSR2, &sa, 0);
249 sigaction(SIGPOLL, &sa, 0);
250 sigaction(SIGPROF, &sa, 0);
251 sigaction(SIGSYS, &sa, 0);
252 sigaction(SIGTRAP, &sa, 0);
253 sigaction(SIGVTALRM, &sa, 0);
254 sigaction(SIGXCPU, &sa, 0);
255 sigaction(SIGXFSZ, &sa, 0);
259 #define PARSE_FLAGS_NOTSUPP_OK 0x0001
260 #define PARSE_FLAGS_FORCE_FN 0x0002
262 static void parse_salt(char *salt_str, int flags)
264 unsigned char buf[EXT4_MAX_SALT_SIZE];
266 unsigned char *salt_buf;
267 int fd, ret, salt_len = 0;
269 if (flags & PARSE_FLAGS_FORCE_FN)
270 goto salt_from_filename;
271 if (strncmp(cp, "s:", 2) == 0) {
273 salt_len = strlen(cp);
274 if (salt_len >= EXT4_MAX_SALT_SIZE)
276 strncpy((char *) buf, cp, sizeof(buf));
277 } else if (cp[0] == '/') {
279 fd = open(cp, O_RDONLY | O_DIRECTORY);
280 if (fd == -1 && errno == ENOTDIR)
281 fd = open(cp, O_RDONLY);
286 ret = ioctl(fd, EXT4_IOC_GET_ENCRYPTION_PWSALT, &buf);
289 if (flags & PARSE_FLAGS_NOTSUPP_OK)
291 perror("EXT4_IOC_GET_ENCRYPTION_PWSALT");
294 if (options & OPT_VERBOSE) {
296 uuid_unparse(buf, tmp);
297 printf("%s has pw salt %s\n", cp, tmp);
300 } else if (strncmp(cp, "f:", 2) == 0) {
302 goto salt_from_filename;
303 } else if (strncmp(cp, "0x", 2) == 0) {
304 unsigned char *h, *l;
310 if (salt_len >= EXT4_MAX_SALT_SIZE)
312 h = memchr(hexchars, *cp++, hexchars_size);
313 l = memchr(hexchars, *cp++, hexchars_size);
317 (((unsigned char)(h - hexchars) << 4) +
318 (unsigned char)(l - hexchars));
320 } else if (uuid_parse(cp, buf) == 0) {
324 fprintf(stderr, "Invalid salt: %s\n", salt_str);
327 salt_buf = malloc(salt_len);
329 fprintf(stderr, "Couldn't allocate salt\n");
332 memcpy(salt_buf, buf, salt_len);
333 add_salt(salt_buf, salt_len);
336 static void set_policy(struct salt *set_salt, int pad,
337 int argc, char *argv[], int path_start_index)
340 struct ext4_encryption_policy policy;
346 if ((pad != 4) && (pad != 8) &&
347 (pad != 16) && (pad != 32)) {
348 fprintf(stderr, "Invalid padding %d\n", pad);
352 for (x = path_start_index; x < argc; x++) {
353 fd = open(argv[x], O_DIRECTORY);
361 if (ioctl(fd, EXT4_IOC_GET_ENCRYPTION_PWSALT,
363 perror("EXT4_IOC_GET_ENCRYPTION_PWSALT");
366 salt = find_by_salt(uu, sizeof(uu));
368 fprintf(stderr, "Couldn't find salt!?!\n");
373 policy.contents_encryption_mode =
374 EXT4_ENCRYPTION_MODE_AES_256_XTS;
375 policy.filenames_encryption_mode =
376 EXT4_ENCRYPTION_MODE_AES_256_CTS;
377 policy.flags = ext2fs_log2(pad >> 2);
378 memcpy(policy.master_key_descriptor, salt->key_desc,
379 EXT4_KEY_DESCRIPTOR_SIZE);
380 rc = ioctl(fd, EXT4_IOC_SET_ENCRYPTION_POLICY, &policy);
383 printf("Error [%s] setting policy.\nThe key descriptor "
384 "[%s] may not match the existing encryption "
385 "context for directory [%s].\n",
386 strerror(errno), salt->key_ref_str, argv[x]);
389 printf("Key with descriptor [%s] applied to %s.\n",
390 salt->key_ref_str, argv[x]);
394 static void pbkdf2_sha512(const char *passphrase, struct salt *salt,
396 unsigned char derived_key[EXT4_MAX_KEY_SIZE])
398 size_t passphrase_size = strlen(passphrase);
399 unsigned char buf[SHA512_LENGTH + EXT4_MAX_PASSPHRASE_SIZE] = {0};
400 unsigned char tempbuf[SHA512_LENGTH] = {0};
401 char final[SHA512_LENGTH] = {0};
402 unsigned char saltbuf[EXT4_MAX_SALT_SIZE + EXT4_MAX_PASSPHRASE_SIZE] = {0};
403 int actual_buf_len = SHA512_LENGTH + passphrase_size;
404 int actual_saltbuf_len = EXT4_MAX_SALT_SIZE + passphrase_size;
406 __u32 *final_u32 = (__u32 *)final;
407 __u32 *temp_u32 = (__u32 *)tempbuf;
409 if (passphrase_size > EXT4_MAX_PASSPHRASE_SIZE) {
410 printf("Passphrase size is %zd; max is %d.\n", passphrase_size,
411 EXT4_MAX_PASSPHRASE_SIZE);
414 if (salt->salt_len > EXT4_MAX_SALT_SIZE) {
415 printf("Salt size is %zd; max is %d.\n", salt->salt_len,
419 assert(EXT4_MAX_KEY_SIZE <= SHA512_LENGTH);
421 memcpy(saltbuf, salt->salt, salt->salt_len);
422 memcpy(&saltbuf[EXT4_MAX_SALT_SIZE], passphrase, passphrase_size);
424 memcpy(&buf[SHA512_LENGTH], passphrase, passphrase_size);
426 for (x = 0; x < count; ++x) {
428 ext2fs_sha512(saltbuf, actual_saltbuf_len, tempbuf);
431 * buf: [previous hash || passphrase]
433 memcpy(buf, tempbuf, SHA512_LENGTH);
434 ext2fs_sha512(buf, actual_buf_len, tempbuf);
436 for (y = 0; y < (sizeof(final) / sizeof(*final_u32)); ++y)
437 final_u32[y] = final_u32[y] ^ temp_u32[y];
439 memcpy(derived_key, final, EXT4_MAX_KEY_SIZE);
442 static int disable_echo(struct termios *saved_settings)
444 struct termios current_settings;
447 rc = tcgetattr(0, ¤t_settings);
450 *saved_settings = current_settings;
451 current_settings.c_lflag &= ~ECHO;
452 rc = tcsetattr(0, TCSANOW, ¤t_settings);
457 static void get_passphrase(char *passphrase, int len)
460 struct termios current_settings;
463 disable_echo(¤t_settings);
464 p = fgets(passphrase, len, stdin);
465 tcsetattr(0, TCSANOW, ¤t_settings);
468 printf("Aborting.\n");
471 p = strrchr(passphrase, '\n');
473 p = passphrase + len - 1;
483 static const struct keyring_map keyrings[] = {
484 {"@us", 3, KEY_SPEC_USER_SESSION_KEYRING},
485 {"@u", 2, KEY_SPEC_USER_KEYRING},
486 {"@s", 2, KEY_SPEC_SESSION_KEYRING},
487 {"@g", 2, KEY_SPEC_GROUP_KEYRING},
488 {"@p", 2, KEY_SPEC_PROCESS_KEYRING},
489 {"@t", 2, KEY_SPEC_THREAD_KEYRING},
492 static int get_keyring_id(const char *keyring)
498 * If no keyring is specified, by default use either the user
499 * session keyring or the session keyring. Fetching the
500 * session keyring will return the user session keyring if no
501 * session keyring has been set.
504 return KEY_SPEC_SESSION_KEYRING;
505 for (x = 0; x < (sizeof(keyrings) / sizeof(keyrings[0])); ++x) {
506 if (strcmp(keyring, keyrings[x].name) == 0) {
507 return keyrings[x].code;
510 x = strtoul(keyring, &end, 10);
512 if (keyctl(KEYCTL_DESCRIBE, x, NULL, 0) < 0)
519 static void generate_key_ref_str(struct salt *salt)
521 unsigned char key_ref1[SHA512_LENGTH];
522 unsigned char key_ref2[SHA512_LENGTH];
525 ext2fs_sha512(salt->key, EXT4_MAX_KEY_SIZE, key_ref1);
526 ext2fs_sha512(key_ref1, SHA512_LENGTH, key_ref2);
527 memcpy(salt->key_desc, key_ref2, EXT4_KEY_DESCRIPTOR_SIZE);
528 for (x = 0; x < EXT4_KEY_DESCRIPTOR_SIZE; ++x) {
529 sprintf(&salt->key_ref_str[x * 2], "%02x",
532 salt->key_ref_str[EXT4_KEY_REF_STR_BUF_SIZE - 1] = '\0';
535 static void insert_key_into_keyring(const char *keyring, struct salt *salt)
537 int keyring_id = get_keyring_id(keyring);
538 struct ext4_encryption_key key;
539 char key_ref_full[EXT2FS_KEY_DESC_PREFIX_SIZE +
540 EXT4_KEY_REF_STR_BUF_SIZE];
543 if (keyring_id == 0) {
544 printf("Invalid keyring [%s].\n", keyring);
547 sprintf(key_ref_full, "%s%s", EXT2FS_KEY_DESC_PREFIX,
549 rc = keyctl(KEYCTL_SEARCH, keyring_id, EXT2FS_KEY_TYPE_LOGON,
552 if ((options & OPT_QUIET) == 0)
553 printf("Key with descriptor [%s] already exists\n",
556 } else if ((rc == -1) && (errno != ENOKEY)) {
557 printf("keyctl_search failed: %s\n", strerror(errno));
559 printf("Keyring [%s] is not available.\n", keyring);
562 key.mode = EXT4_ENCRYPTION_MODE_AES_256_XTS;
563 memcpy(key.raw, salt->key, EXT4_MAX_KEY_SIZE);
564 key.size = EXT4_MAX_KEY_SIZE;
567 * We need to do this instead of simply adding the key to
568 * KEY_SPEC_SESSION_KEYRING since trying to add a key to a
569 * session keyring that does not yet exist will cause the
570 * kernel to create a session keyring --- which will then get
571 * garbage collected as soon as e4crypt exits.
573 * The fact that the keyctl system call and the add_key system
574 * call treats KEY_SPEC_SESSION_KEYRING differently when a
575 * session keyring does not exist is very unfortunate and
576 * confusing, but so it goes...
578 if (keyring_id == KEY_SPEC_SESSION_KEYRING) {
579 keyring_id = keyctl(KEYCTL_GET_KEYRING_ID, keyring_id, 0);
580 if (keyring_id < 0) {
581 printf("Error getting session keyring ID: %s\n",
586 rc = add_key(EXT2FS_KEY_TYPE_LOGON, key_ref_full, (void *)&key,
587 sizeof(key), keyring_id);
589 if (errno == EDQUOT) {
590 printf("Error adding key to keyring; quota exceeded\n");
592 printf("Error adding key with key descriptor [%s]: "
593 "%s\n", salt->key_ref_str, strerror(errno));
597 if ((options & OPT_QUIET) == 0)
598 printf("Added key with descriptor [%s]\n",
603 static void get_default_salts(void)
605 FILE *f = setmntent("/etc/mtab", "r");
608 while (f && ((mnt = getmntent(f)) != NULL)) {
609 if (strcmp(mnt->mnt_type, "ext4") ||
610 access(mnt->mnt_dir, R_OK))
612 parse_salt(mnt->mnt_dir, PARSE_FLAGS_NOTSUPP_OK);
617 /* Functions which implement user commands */
620 const char *cmd_name;
621 void (*cmd_func)(int, char **, const struct cmd_desc *);
622 const char *cmd_desc;
623 const char *cmd_help;
627 #define CMD_HIDDEN 0x0001
629 static void do_help(int argc, char **argv, const struct cmd_desc *cmd);
631 #define add_key_desc "adds a key to the user's keyring"
632 #define add_key_help \
633 "e4crypt add_key -S salt [ -k keyring ] [-v] [-q] [ -p pad ] [ path ... ]\n\n" \
634 "Prompts the user for a passphrase and inserts it into the specified\n" \
635 "keyring. If no keyring is specified, e4crypt will use the session\n" \
636 "keyring if it exists or the user session keyring if it does not.\n\n" \
637 "If one or more directory paths are specified, e4crypt will try to\n" \
638 "set the policy of those directories to use the key just entered by\n" \
641 static void do_add_key(int argc, char **argv, const struct cmd_desc *cmd)
644 bool explicit_salt = false;
645 char *keyring = NULL;
649 while ((opt = getopt(argc, argv, "k:S:p:vq")) != -1) {
652 /* Specify a keyring. */
660 fputs("May only provide -S once\n", stderr);
663 /* Salt value for passphrase. */
664 parse_salt(optarg, 0);
665 explicit_salt = true;
668 options |= OPT_VERBOSE;
671 options |= OPT_QUIET;
676 fprintf(stderr, "Unrecognized option: %c\n",
678 fputs("USAGE:\n ", stderr);
679 fputs(cmd->cmd_help, stderr);
686 fprintf(stderr, "No salt values available\n");
689 validate_paths(argc, argv, optind);
691 for (i = optind; i < argc; i++)
692 parse_salt(argv[i], PARSE_FLAGS_FORCE_FN);
693 printf("Enter passphrase (echo disabled): ");
694 get_passphrase(in_passphrase, sizeof(in_passphrase));
695 for (j = 0, salt = salt_list; j < num_salt; j++, salt++) {
696 pbkdf2_sha512(in_passphrase, salt,
697 EXT4_PBKDF2_ITERATIONS, salt->key);
698 generate_key_ref_str(salt);
699 insert_key_into_keyring(keyring, salt);
701 if (optind != argc) {
702 salt = explicit_salt ? salt_list : NULL;
703 set_policy(salt, pad, argc, argv, optind);
709 #define set_policy_desc "sets a policy for directories"
710 #define set_policy_help \
711 "e4crypt set_policy [ -p pad ] policy path ... \n\n" \
712 "Sets the policy for the directories specified on the command line.\n" \
713 "All directories must be empty to set the policy; if the directory\n" \
714 "already has a policy established, e4crypt will validate that it the\n" \
715 "policy matches what was specified. A policy is an encryption key\n" \
716 "identifier consisting of 16 hexadecimal characters.\n"
718 static void do_set_policy(int argc, char **argv, const struct cmd_desc *cmd)
723 while ((c = getopt (argc, argv, "p:")) != EOF) {
731 if (argc < optind + 2) {
732 fprintf(stderr, "Missing required argument(s).\n\n");
733 fputs("USAGE:\n ", stderr);
734 fputs(cmd->cmd_help, stderr);
738 if ((strlen(argv[optind]) != (EXT4_KEY_DESCRIPTOR_SIZE * 2)) ||
739 hex2byte(argv[optind], (EXT4_KEY_DESCRIPTOR_SIZE * 2),
740 saltbuf.key_desc, EXT4_KEY_DESCRIPTOR_SIZE)) {
741 printf("Invalid key descriptor [%s]. Valid characters "
742 "are 0-9 and a-f, lower case. "
743 "Length must be %d.\n",
744 argv[optind], (EXT4_KEY_DESCRIPTOR_SIZE * 2));
747 validate_paths(argc, argv, optind+1);
748 strcpy(saltbuf.key_ref_str, argv[optind]);
749 set_policy(&saltbuf, pad, argc, argv, optind+1);
753 #define get_policy_desc "get the encryption for directories"
754 #define get_policy_help \
755 "e4crypt get_policy path ... \n\n" \
756 "Gets the policy for the directories specified on the command line.\n"
758 static void do_get_policy(int argc, char **argv, const struct cmd_desc *cmd)
760 struct ext4_encryption_policy policy;
764 fprintf(stderr, "Missing required argument(s).\n\n");
765 fputs("USAGE:\n ", stderr);
766 fputs(cmd->cmd_help, stderr);
770 for (i = 1; i < argc; i++) {
771 fd = open(argv[i], O_RDONLY);
776 rc = ioctl(fd, EXT4_IOC_GET_ENCRYPTION_POLICY, &policy);
779 printf("Error getting policy for %s: %s\n",
780 argv[i], strerror(errno));
783 printf("%s: ", argv[i]);
784 for (j = 0; j < EXT4_KEY_DESCRIPTOR_SIZE; j++) {
785 printf("%02x", (unsigned char) policy.master_key_descriptor[j]);
792 #define new_session_desc "give the invoking process a new session keyring"
793 #define new_session_help \
794 "e4crypt new_session\n\n" \
795 "Give the invoking process (typically a shell) a new session keyring,\n" \
796 "discarding its old session keyring.\n"
798 static void do_new_session(int argc, char **argv EXT2FS_ATTR((unused)),
799 const struct cmd_desc *cmd)
804 fputs("Excess arguments\n\n", stderr);
805 fputs(cmd->cmd_help, stderr);
808 keyid = keyctl(KEYCTL_JOIN_SESSION_KEYRING, NULL);
810 perror("KEYCTL_JOIN_SESSION_KEYRING");
813 ret = keyctl(KEYCTL_SESSION_TO_PARENT, NULL);
815 perror("KEYCTL_SESSION_TO_PARENT");
818 printf("Switched invoking process to new session keyring %ld\n", keyid);
822 #define CMD(name) { #name, do_##name, name##_desc, name##_help, 0 }
823 #define _CMD(name) { #name, do_##name, NULL, NULL, CMD_HIDDEN }
825 const struct cmd_desc cmd_list[] = {
831 { NULL, NULL, NULL, NULL, 0 }
834 static void do_help(int argc, char **argv,
835 const struct cmd_desc *cmd EXT2FS_ATTR((unused)))
837 const struct cmd_desc *p;
840 for (p = cmd_list; p->cmd_name; p++) {
841 if (p->cmd_flags & CMD_HIDDEN)
843 if (strcmp(p->cmd_name, argv[1]) == 0) {
845 fputs("USAGE:\n ", stdout);
846 fputs(p->cmd_help, stdout);
850 printf("Unknown command: %s\n\n", argv[1]);
853 fputs("Available commands:\n", stdout);
854 for (p = cmd_list; p->cmd_name; p++) {
855 if (p->cmd_flags & CMD_HIDDEN)
857 printf(" %-20s %s\n", p->cmd_name, p->cmd_desc);
859 printf("\nTo get more information on a command, "
860 "type 'e4crypt help cmd'\n");
864 int main(int argc, char *argv[])
866 const struct cmd_desc *cmd;
869 do_help(argc, argv, cmd_list);
872 for (cmd = cmd_list; cmd->cmd_name; cmd++) {
873 if (strcmp(cmd->cmd_name, argv[1]) == 0) {
874 cmd->cmd_func(argc-1, argv+1, cmd);
878 printf("Unknown command: %s\n\n", argv[1]);
879 do_help(1, argv, cmd_list);