UBOOTコンソールのスペースを使用してパラメータを使用するにはどうすればよいですか？

Question

UBOOTで「fatload」を使用しようとしています。これはパラメータとしてファイルパスをとります。私はスペースを使って1つを渡すことはできません。

例入力：

fatload mmc 0:1 0x70800000 /somedir/file name with spaces.txt 

結果：私は

「/ somedir

"spaces.txtと/ somedir /ファイル名" を試してみました

reading /somedir/file 

** Unable to read "/somedir/file" from mmc 0:1 ** 

/ファイル名とspaces.txt '

/somedir /ファイル\ spaces.txt

fatloadと\ spaces.txt

とにも

のsetenvファイルパス/ somedir /ファイル名を持つ名\ ... $ {ファイルパス}

何も動作していないようです！一時的にファイル名を変更することを検討しましたが、可能かどうかわかりません。私はubootのこのバージョンは、単に」ことができると思い

：それ書き込みが発生する場所を私は知らない...

UPDATE - 多分直接どこか、MMCを書きで行うことができますどのパラメータでもスペースを取らない！私はソースからの専門家を含めました。私は良い仕事が必要なように見えます！ （ここで悪用しようとするトリックがない限り）

fatload/fatlsを実行するための適切なubootソースがあります。 argv [4]にスペースを入れるにはどうすればよいですか？ここで

/* 
* (C) Copyright 2002 
* Richard Jones, rjones@nexus-tech.net 
* 
* See file CREDITS for list of people who contributed to this 
* project. 
* 
* This program is free software; you can redistribute it and/or 
* modify it under the terms of the GNU General Public License as 
* published by the Free Software Foundation; either version 2 of 
* the License, or (at your option) any later version. 
* 
* This program is distributed in the hope that it will be useful, 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
* GNU General Public License for more details. 
* 
* You should have received a copy of the GNU General Public License 
* along with this program; if not, write to the Free Software 
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
* MA 02111-1307 USA 
*/ 

/* 
* Boot support 
*/ 
#include <common.h> 
#include <command.h> 
#include <s_record.h> 
#include <net.h> 
#include <ata.h> 
#include <part.h> 
#include <fat.h> 


int do_fat_fsload (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) 
{ 
    long size; 
    unsigned long offset; 
    unsigned long count; 
    char buf [12]; 
    block_dev_desc_t *dev_desc=NULL; 
    int dev=0; 
    int part=1; 
    char *ep; 

    if (argc < 5) { 
     printf ("usage: fatload <interface> <dev[:part]> <addr> <filename> [bytes]\n"); 
     return 1; 
    } 
    dev = (int)simple_strtoul (argv[2], &ep, 16); 
    dev_desc=get_dev(argv[1],dev); 
    if (dev_desc==NULL) { 
     puts ("\n** Invalid boot device **\n"); 
     return 1; 
    } 
    if (*ep) { 
     if (*ep != ':') { 
      puts ("\n** Invalid boot device, use `dev[:part]' **\n"); 
      return 1; 
     } 
     part = (int)simple_strtoul(++ep, NULL, 16); 
    } 
    if (fat_register_device(dev_desc,part)!=0) { 
     printf ("\n** Unable to use %s %d:%d for fatload **\n",argv[1],dev,part); 
     return 1; 
    } 
    offset = simple_strtoul (argv[3], NULL, 16); 
    if (argc == 6) 
     count = simple_strtoul (argv[5], NULL, 16); 
    else 
     count = 0; 
    size = file_fat_read (argv[4], (unsigned char *) offset, count); 

    if(size==-1) { 
     printf("\n** Unable to read \"%s\" from %s %d:%d **\n",argv[4],argv[1],dev,part); 
     return 1; 
    } 

    printf ("\n%ld bytes read\n", size); 

    sprintf(buf, "%lX", size); 
    setenv("filesize", buf); 

    return 0; 
} 


U_BOOT_CMD(
    fatload, 6, 0, do_fat_fsload, 
    "load binary file from a dos filesystem", 
    "<interface> <dev[:part]> <addr> <filename> [bytes]\n" 
    " - load binary file 'filename' from 'dev' on 'interface'\n" 
    "  to address 'addr' from dos filesystem" 
); 

int do_fat_ls (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) 
{ 
    char *filename = "/"; 
    int ret; 
    int dev=0; 
    int part=1; 
    char *ep; 
    block_dev_desc_t *dev_desc=NULL; 

    if (argc < 3) { 
     printf ("usage: fatls <interface> <dev[:part]> [directory]\n"); 
     return (0); 
    } 
    dev = (int)simple_strtoul (argv[2], &ep, 16); 
    dev_desc=get_dev(argv[1],dev); 
    if (dev_desc==NULL) { 
     puts ("\n** Invalid boot device **\n"); 
     return 1; 
    } 
    if (*ep) { 
     if (*ep != ':') { 
      puts ("\n** Invalid boot device, use `dev[:part]' **\n"); 
      return 1; 
     } 
     part = (int)simple_strtoul(++ep, NULL, 16); 
    } 
    if (fat_register_device(dev_desc,part)!=0) { 
     printf ("\n** Unable to use %s %d:%d for fatls **\n",argv[1],dev,part); 
     return 1; 
    } 
    if (argc == 4) 
     ret = file_fat_ls (argv[3]); 
    else 
     ret = file_fat_ls (filename); 

    if(ret!=0) 
     printf("No Fat FS detected\n"); 
    return (ret); 
} 

U_BOOT_CMD(
    fatls, 4, 1, do_fat_ls, 
    "list files in a directory (default /)", 
    "<interface> <dev[:part]> [directory]\n" 
    " - list files from 'dev' on 'interface' in a 'directory'" 
); 

int do_fat_fsinfo (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) 
{ 
    int dev=0; 
    int part=1; 
    char *ep; 
    block_dev_desc_t *dev_desc=NULL; 

    if (argc < 2) { 
     printf ("usage: fatinfo <interface> <dev[:part]>\n"); 
     return (0); 
    } 
    dev = (int)simple_strtoul (argv[2], &ep, 16); 
    dev_desc=get_dev(argv[1],dev); 
    if (dev_desc==NULL) { 
     puts ("\n** Invalid boot device **\n"); 
     return 1; 
    } 
    if (*ep) { 
     if (*ep != ':') { 
      puts ("\n** Invalid boot device, use `dev[:part]' **\n"); 
      return 1; 
     } 
     part = (int)simple_strtoul(++ep, NULL, 16); 
    } 
    if (fat_register_device(dev_desc,part)!=0) { 
     printf ("\n** Unable to use %s %d:%d for fatinfo **\n",argv[1],dev,part); 
     return 1; 
    } 
    return (file_fat_detectfs()); 
} 

U_BOOT_CMD(
    fatinfo, 3, 1, do_fat_fsinfo, 
    "print information about filesystem", 
    "<interface> <dev[:part]>\n" 
    " - print information about filesystem from 'dev' on 'interface'" 
); 

#ifdef NOT_IMPLEMENTED_YET 
/* find first device whose first partition is a DOS filesystem */ 
int find_fat_partition (void) 
{ 
    int i, j; 
    block_dev_desc_t *dev_desc; 
    unsigned char *part_table; 
    unsigned char buffer[ATA_BLOCKSIZE]; 

    for (i = 0; i < CONFIG_SYS_IDE_MAXDEVICE; i++) { 
     dev_desc = ide_get_dev (i); 
     if (!dev_desc) { 
      debug ("couldn't get ide device!\n"); 
      return (-1); 
     } 
     if (dev_desc->part_type == PART_TYPE_DOS) { 
      if (dev_desc-> 
       block_read (dev_desc->dev, 0, 1, (ulong *) buffer) != 1) { 
       debug ("can't perform block_read!\n"); 
       return (-1); 
      } 
      part_table = &buffer[0x1be]; /* start with partition #4 */ 
      for (j = 0; j < 4; j++) { 
       if ((part_table[4] == 1 || /* 12-bit FAT */ 
        part_table[4] == 4 || /* 16-bit FAT */ 
        part_table[4] == 6) && /* > 32Meg part */ 
        part_table[0] == 0x80) { /* bootable? */ 
        curr_dev = i; 
        part_offset = part_table[11]; 
        part_offset <<= 8; 
        part_offset |= part_table[10]; 
        part_offset <<= 8; 
        part_offset |= part_table[9]; 
        part_offset <<= 8; 
        part_offset |= part_table[8]; 
        debug ("found partition start at %ld\n", part_offset); 
        return (0); 
       } 
       part_table += 16; 
      } 
     } 
    } 

    debug ("no valid devices found!\n"); 
    return (-1); 
} 

int 
do_fat_dump (cmd_tbl_t *cmdtp, bd_t *bd, int flag, int argc, char *argv[]) 
{ 
    __u8 block[1024]; 
    int ret; 
    int bknum; 

    ret = 0; 

    if (argc != 2) { 
     printf ("needs an argument!\n"); 
     return (0); 
    } 

    bknum = simple_strtoul (argv[1], NULL, 10); 

    if (disk_read (0, bknum, block) != 0) { 
     printf ("Error: reading block\n"); 
     return -1; 
    } 
    printf ("FAT dump: %d\n", bknum); 
    hexdump (512, block); 

    return (ret); 
} 

int disk_read (__u32 startblock, __u32 getsize, __u8 *bufptr) 
{ 
    ulong tot; 
    block_dev_desc_t *dev_desc; 

    if (curr_dev < 0) { 
     if (find_fat_partition() != 0) 
      return (-1); 
    } 

    dev_desc = ide_get_dev (curr_dev); 
    if (!dev_desc) { 
     debug ("couldn't get ide device\n"); 
     return (-1); 
    } 

    tot = dev_desc->block_read (0, startblock + part_offset, 
        getsize, (ulong *) bufptr); 

    /* should we do this here? 
     flush_cache ((ulong)buf, cnt*ide_dev_desc[device].blksz); 
    */ 

    if (tot == getsize) 
     return (0); 

    debug ("unable to read from device!\n"); 

    return (-1); 
} 


static int isprint (unsigned char ch) 
{ 
    if (ch >= 32 && ch < 127) 
     return (1); 

    return (0); 
} 


void hexdump (int cnt, unsigned char *data) 
{ 
    int i; 
    int run; 
    int offset; 

    offset = 0; 
    while (cnt) { 
     printf ("%04X : ", offset); 
     if (cnt >= 16) 
      run = 16; 
     else 
      run = cnt; 
     cnt -= run; 
     for (i = 0; i < run; i++) 
      printf ("%02X ", (unsigned int) data[i]); 
     printf (": "); 
     for (i = 0; i < run; i++) 
      printf ("%c", isprint (data[i]) ? data[i] : '.'); 
     printf ("\n"); 
     data = &data[16]; 
     offset += run; 
    } 
} 
#endif /* NOT_IMPLEMENTED_YET */ 

はubootコマンドを実行するためのソースです：ここで

int run_command (const char *cmd, int flag) 
{ 
    cmd_tbl_t *cmdtp; 
    char cmdbuf[CONFIG_SYS_CBSIZE]; /* working copy of cmd  */ 
    char *token;   /* start of token in cmdbuf */ 
    char *sep;   /* end of token (separator) in cmdbuf */ 
    char finaltoken[CONFIG_SYS_CBSIZE]; 
    char *str = cmdbuf; 
    char *argv[CONFIG_SYS_MAXARGS + 1]; /* NULL terminated */ 
    int argc, inquotes; 
    int repeatable = 1; 
    int rc = 0; 

#ifdef DEBUG_PARSER 
    printf ("[RUN_COMMAND] cmd[%p]=\"", cmd); 
    puts (cmd ? cmd : "NULL"); /* use puts - string may be loooong */ 
    puts ("\"\n"); 
#endif 

    clear_ctrlc();  /* forget any previous Control C */ 

    if (!cmd || !*cmd) { 
     return -1; /* empty command */ 
    } 

    if (strlen(cmd) >= CONFIG_SYS_CBSIZE) { 
     puts ("## Command too long!\n"); 
     return -1; 
    } 

    strcpy (cmdbuf, cmd); 

    /* Process separators and check for invalid 
    * repeatable commands 
    */ 

#ifdef DEBUG_PARSER 
    printf ("[PROCESS_SEPARATORS] %s\n", cmd); 
#endif 
    while (*str) { 

     /* 
     * Find separator, or string end 
     * Allow simple escape of ';' by writing "\;" 
     */ 
     for (inquotes = 0, sep = str; *sep; sep++) { 
      if ((*sep=='\'') && 
       (*(sep-1) != '\\')) 
       inquotes=!inquotes; 

      if (!inquotes && 
       (*sep == ';') && /* separator  */ 
       (sep != str) && /* past string start */ 
       (*(sep-1) != '\\')) /* and NOT escaped */ 
       break; 
     } 

     /* 
     * Limit the token to data between separators 
     */ 
     token = str; 
     if (*sep) { 
      str = sep + 1; /* start of command for next pass */ 
      *sep = '\0'; 
     } 
     else 
      str = sep; /* no more commands for next pass */ 
#ifdef DEBUG_PARSER 
     printf ("token: \"%s\"\n", token); 
#endif 

     /* find macros in this token and replace them */ 
     process_macros (token, finaltoken); 

     /* Extract arguments */ 
     if ((argc = parse_line (finaltoken, argv)) == 0) { 
      rc = -1; /* no command at all */ 
      continue; 
     } 

     /* Look up command in command table */ 
     if ((cmdtp = find_cmd(argv[0])) == NULL) { 
      printf ("Unknown command '%s' - try 'help'\n", argv[0]); 
      rc = -1; /* give up after bad command */ 
      continue; 
     } 

     /* found - check max args */ 
     if (argc > cmdtp->maxargs) { 
      cmd_usage(cmdtp); 
      rc = -1; 
      continue; 
     } 

#if defined(CONFIG_CMD_BOOTD) 
     /* avoid "bootd" recursion */ 
     if (cmdtp->cmd == do_bootd) { 
#ifdef DEBUG_PARSER 
      printf ("[%s]\n", finaltoken); 
#endif 
      if (flag & CMD_FLAG_BOOTD) { 
       puts ("'bootd' recursion detected\n"); 
       rc = -1; 
       continue; 
      } else { 
       flag |= CMD_FLAG_BOOTD; 
      } 
     } 
#endif 

     /* OK - call function to do the command */ 
     if ((cmdtp->cmd) (cmdtp, flag, argc, argv) != 0) { 
      rc = -1; 
     } 

     repeatable &= cmdtp->repeatable; 

     /* Did the user stop this? */ 
     if (had_ctrlc()) 
      return -1; /* if stopped then not repeatable */ 
    } 

    return rc ? rc : repeatable; 
} 

/****************************************************************************/ 

#if defined(CONFIG_CMD_RUN) 
int do_run (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[]) 
{ 
    int i; 

    if (argc < 2) { 
     cmd_usage(cmdtp); 
     return 1; 
    } 

    for (i=1; i<argc; ++i) { 
     char *arg; 

     if ((arg = getenv (argv[i])) == NULL) { 
      printf ("## Error: \"%s\" not defined\n", argv[i]); 
      return 1; 
     } 
#ifndef CONFIG_SYS_HUSH_PARSER 
     if (run_command (arg, flag) == -1) 
      return 1; 
#else 
     if (parse_string_outer(arg, 
      FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP) != 0) 
      return 1; 
#endif 
    } 
    return 0; 
} 
#endif 

は、コマンドの引数の解析です：あなたはU-ブートの

int parse_line (char *line, char *argv[]) 
{ 
    int nargs = 0; 

#ifdef DEBUG_PARSER 
    printf ("parse_line: \"%s\"\n", line); 
#endif 
    while (nargs < CONFIG_SYS_MAXARGS) { 

     /* skip any white space */ 
     while ((*line == ' ') || (*line == '\t')) { 
      ++line; 
     } 

     if (*line == '\0') { /* end of line, no more args */ 
      argv[nargs] = NULL; 
#ifdef DEBUG_PARSER 
     printf ("parse_line: nargs=%d\n", nargs); 
#endif 
      return (nargs); 
     } 

     argv[nargs++] = line; /* begin of argument string */ 

     /* find end of string */ 
     while (*line && (*line != ' ') && (*line != '\t')) { 
      ++line; 
     } 

     if (*line == '\0') { /* end of line, no more args */ 
      argv[nargs] = NULL; 
#ifdef DEBUG_PARSER 
     printf ("parse_line: nargs=%d\n", nargs); 
#endif 
      return (nargs); 
     } 

     *line++ = '\0';  /* terminate current arg  */ 
    } 

    printf ("** Too many args (max. %d) **\n", CONFIG_SYS_MAXARGS); 

#ifdef DEBUG_PARSER 
    printf ("parse_line: nargs=%d\n", nargs); 
#endif 
    return (nargs); 
} 

Answer 1

まあ、私は、ディスクのFATを編集進を開始し、それが夜が明けました私は短くて長いファイル名のエントリを読みましたが、ちょっとしたファイル名でfatloadやfatlsなどを試してみてはいかがですか？私はそれを試み、それは働いた！

トリックは、さまざまな条件の下で対応する短い名前が何であるかを把握しています（私はそれを直接リストする方法がないので）。しかし、私はロジックを試しています。

この回答はあなたにカット/ペーストを与えるものではありませんが、同じ問題に対処する必要がある場合は、正しいパス（悪いペンパル！）を設定します。

Answer 2

どのバージョンを使用していますか？ v2016.05と（ "spaces.txtのファイルが" 空で、MMC 0：1 FAT32です：3はMMC 0は、ext4のです）：

=> load mmc 0:3 ${loadaddr} "/tmp/file with spaces.txt" 
0 bytes read in 44 ms (0 Bytes/s) 
=> load mmc 0:1 ${loadaddr} "file with spaces.txt" 
reading file with spaces.txt 
0 bytes read in 5 ms (0 Bytes/s) 
=> fatload mmc 0:1 ${loadaddr} "file with spaces.txt" 
reading file with spaces.txt 
0 bytes read in 5 ms (0 Bytes/s)