| /**************************************************************************** |
| * apps/nshlib/nsh_ddcmd.c |
| * |
| * Copyright (C) 2008-2009, 2012 Gregory Nutt. All rights reserved. |
| * Author: Gregory Nutt <gnutt@nuttx.org> |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * 3. Neither the name NuttX nor the names of its contributors may be |
| * used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
| * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
| * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN |
| * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| * |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Included Files |
| ****************************************************************************/ |
| |
| #include <nuttx/config.h> |
| |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| |
| #include <stdint.h> |
| #include <stdbool.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <string.h> |
| #include <debug.h> |
| #include <errno.h> |
| |
| #include <nuttx/fs/fs.h> |
| |
| #include "nsh.h" |
| #include "nsh_console.h" |
| |
| #if CONFIG_NFILE_DESCRIPTORS > 0 && !defined(CONFIG_NSH_DISABLE_DD) |
| |
| /**************************************************************************** |
| * Definitions |
| ****************************************************************************/ |
| |
| /* If no sector size is specified wity BS=, then the following default value |
| * is used. |
| */ |
| |
| #define DEFAULT_SECTSIZE 512 |
| |
| /* At present, piping of input and output are not support, i.e., both of= |
| * and if= arguments are required. |
| */ |
| |
| #undef CAN_PIPE_FROM_STD |
| |
| /* Function pointer calls are only need if block drivers are supported |
| * (or, rather, if mount points are supported in the file system) |
| */ |
| |
| #ifndef CONFIG_DISABLE_MOUNTPOINT |
| # define DD_INFD ((dd)->inf.fd) |
| # define DD_INHANDLE ((dd)->inf.handle) |
| # define DD_OUTFD ((dd)->outf.fd) |
| # define DD_OUTHANDLE ((dd)->outf.handle) |
| # define DD_READ(dd) ((dd)->infread(dd)) |
| # define DD_WRITE(dd) ((dd)->outfwrite(dd)) |
| # define DD_INCLOSE(dd) ((dd)->infclose(dd)) |
| # define DD_OUTCLOSE(dd) ((dd)->outfclose(dd)) |
| #else |
| # define DD_INFD ((dd)->infd) |
| # undef DD_INHANDLE |
| # define DD_OUTFD ((dd)->outfd) |
| # undef DD_OUTHANDLE |
| # define DD_READ(dd) dd_readch(dd) |
| # define DD_WRITE(dd) dd_writech(dd) |
| # define DD_INCLOSE(dd) dd_infclosech(dd) |
| # define DD_OUTCLOSE(dd) dd_outfclosech(dd) |
| #endif |
| |
| /**************************************************************************** |
| * Private Types |
| ****************************************************************************/ |
| |
| struct dd_s |
| { |
| FAR struct nsh_vtbl_s *vtbl; |
| |
| #ifndef CONFIG_DISABLE_MOUNTPOINT |
| union |
| { |
| FAR void *handle; /* BCH lib handle for block device */ |
| int fd; /* File descriptor of the character device */ |
| } inf; |
| #else |
| int infd; /* File descriptor of the input device */ |
| #endif |
| |
| #ifndef CONFIG_DISABLE_MOUNTPOINT |
| union |
| { |
| FAR void *handle; /* BCH lib handle for block device */ |
| int fd; /* File descriptor of the character device */ |
| } outf; |
| #else |
| int outfd; /* File descriptor of the output device */ |
| #endif |
| |
| uint32_t nsectors; /* Number of sectors to transfer */ |
| uint32_t sector; /* The current sector number */ |
| uint32_t skip; /* The number of sectors skipped on input */ |
| bool eof; /* true: The of the input or output file has been hit */ |
| uint16_t sectsize; /* Size of one sector */ |
| uint16_t nbytes; /* Number of valid bytes in the buffer */ |
| uint8_t *buffer; /* Buffer of data to write to the output file */ |
| |
| /* Function pointers to handle differences between block and character devices */ |
| |
| #ifndef CONFIG_DISABLE_MOUNTPOINT |
| int (*infread)(struct dd_s *dd); |
| void (*infclose)(struct dd_s *dd); |
| int (*outfwrite)(struct dd_s *dd); |
| void (*outfclose)(struct dd_s *dd); |
| #endif |
| }; |
| |
| /**************************************************************************** |
| * Private Function Prototypes |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Private Data |
| ****************************************************************************/ |
| |
| static const char g_dd[] = "dd"; |
| |
| /**************************************************************************** |
| * Public Data |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Private Functions |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Name: dd_outfcloseblk |
| ****************************************************************************/ |
| |
| #ifndef CONFIG_DISABLE_MOUNTPOINT |
| static void dd_outfcloseblk(struct dd_s *dd) |
| { |
| (void)bchlib_teardown(DD_OUTHANDLE); |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: dd_outfclosech |
| ****************************************************************************/ |
| |
| static void dd_outfclosech(struct dd_s *dd) |
| { |
| (void)close(DD_OUTFD); |
| } |
| |
| /**************************************************************************** |
| * Name: dd_infcloseblk |
| ****************************************************************************/ |
| |
| #ifndef CONFIG_DISABLE_MOUNTPOINT |
| static void dd_infcloseblk(struct dd_s *dd) |
| { |
| (void)bchlib_teardown(DD_INHANDLE); |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: dd_infclosech |
| ****************************************************************************/ |
| |
| static void dd_infclosech(struct dd_s *dd) |
| { |
| (void)close(DD_INFD); |
| } |
| |
| /**************************************************************************** |
| * Name: dd_writeblk |
| ****************************************************************************/ |
| |
| #ifndef CONFIG_DISABLE_MOUNTPOINT |
| static int dd_writeblk(struct dd_s *dd) |
| { |
| ssize_t nbytes; |
| off_t offset = (dd->sector - dd->skip) * dd->sectsize; |
| |
| /* Write the sector at the specified offset */ |
| |
| nbytes = bchlib_write(DD_OUTHANDLE, (char*)dd->buffer, offset, dd->sectsize); |
| if (nbytes < 0) |
| { |
| /* bchlib_write return -EFBIG on attempts to write past the end of |
| * the device. |
| */ |
| |
| if (nbytes == -EFBIG) |
| { |
| dd->eof = true; /* Set end-of-file */ |
| } |
| else |
| { |
| FAR struct nsh_vtbl_s *vtbl = dd->vtbl; |
| nsh_output(vtbl, g_fmtcmdfailed, g_dd, "bshlib_write", NSH_ERRNO_OF(-nbytes)); |
| return ERROR; |
| } |
| } |
| |
| return OK; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: dd_writech |
| ****************************************************************************/ |
| |
| static int dd_writech(struct dd_s *dd) |
| { |
| uint8_t *buffer = dd->buffer; |
| uint16_t written ; |
| ssize_t nbytes; |
| |
| /* Is the out buffer full (or is this the last one)? */ |
| |
| written = 0; |
| do |
| { |
| nbytes = write(DD_OUTFD, buffer, dd->sectsize - written); |
| if (nbytes < 0) |
| { |
| FAR struct nsh_vtbl_s *vtbl = dd->vtbl; |
| nsh_output(vtbl, g_fmtcmdfailed, g_dd, "write", NSH_ERRNO_OF(-nbytes)); |
| return ERROR; |
| } |
| |
| written += nbytes; |
| buffer += nbytes; |
| } |
| while (written < dd->sectsize); |
| |
| return OK; |
| } |
| |
| /**************************************************************************** |
| * Name: dd_readblk |
| ****************************************************************************/ |
| |
| #ifndef CONFIG_DISABLE_MOUNTPOINT |
| static int dd_readblk(struct dd_s *dd) |
| { |
| ssize_t nbytes; |
| off_t offset = dd->sector * dd->sectsize; |
| |
| nbytes = bchlib_read(DD_INHANDLE, (char*)dd->buffer, offset, dd->sectsize); |
| if (nbytes < 0) |
| { |
| FAR struct nsh_vtbl_s *vtbl = dd->vtbl; |
| nsh_output(vtbl, g_fmtcmdfailed, g_dd, "bshlib_read", NSH_ERRNO_OF(-nbytes)); |
| return ERROR; |
| } |
| |
| /* bchlib_read return 0 on attempts to write past the end of the device. */ |
| |
| dd->nbytes = nbytes; |
| dd->eof = (nbytes == 0); |
| return OK; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: dd_readch |
| ****************************************************************************/ |
| |
| static int dd_readch(struct dd_s *dd) |
| { |
| uint8_t *buffer = dd->buffer; |
| ssize_t nbytes; |
| |
| dd->nbytes = 0; |
| do |
| { |
| nbytes = read(DD_INFD, buffer, dd->sectsize - dd->nbytes); |
| if (nbytes < 0) |
| { |
| FAR struct nsh_vtbl_s *vtbl = dd->vtbl; |
| nsh_output(vtbl, g_fmtcmdfailed, g_dd, "read", NSH_ERRNO_OF(-nbytes)); |
| return ERROR; |
| } |
| |
| dd->nbytes += nbytes; |
| buffer += nbytes; |
| } |
| while (dd->nbytes < dd->sectsize && nbytes > 0); |
| |
| dd->eof |= (dd->nbytes == 0); |
| return OK; |
| } |
| |
| /**************************************************************************** |
| * Name: dd_filetype |
| ****************************************************************************/ |
| |
| #ifndef CONFIG_DISABLE_MOUNTPOINT |
| static int dd_filetype(const char *filename) |
| { |
| struct stat sb; |
| int ret; |
| |
| /* Get the type of the file */ |
| |
| ret = stat(filename, &sb); |
| if (ret < 0) |
| { |
| return ERROR; /* Return -1 on failure */ |
| } |
| |
| return S_ISBLK(sb.st_mode); /* Return true(1) if block, false(0) if char */ |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: dd_infopen |
| ****************************************************************************/ |
| |
| #ifndef CONFIG_DISABLE_MOUNTPOINT |
| static inline int dd_infopen(const char *name, struct dd_s *dd) |
| { |
| FAR struct nsh_vtbl_s *vtbl = dd->vtbl; |
| int ret; |
| int type; |
| |
| /* Get the type of the input file */ |
| |
| type = dd_filetype(name); |
| if (type < 0) |
| { |
| nsh_output(vtbl, g_fmtcmdfailed, g_dd, "stat", NSH_ERRNO_OF(-type)); |
| return type; |
| } |
| |
| /* Open the input file */ |
| |
| if (!type) |
| { |
| DD_INFD = open(name, O_RDONLY); |
| if (DD_INFD < 0) |
| { |
| nsh_output(vtbl, g_fmtcmdfailed, g_dd, "open", NSH_ERRNO); |
| return ERROR; |
| } |
| |
| dd->infread = dd_readch; /* Character oriented read */ |
| dd->infclose = dd_infclosech; |
| } |
| else |
| { |
| ret = bchlib_setup(name, true, &DD_INHANDLE); |
| if (ret < 0) |
| { |
| return ERROR; |
| } |
| |
| dd->infread = dd_readblk; |
| dd->infclose = dd_infcloseblk; |
| } |
| |
| return OK; |
| } |
| #else |
| static inline int dd_infopen(const char *name, struct dd_s *dd) |
| { |
| DD_INFD = open(name, O_RDONLY); |
| if (DD_INFD < 0) |
| { |
| FAR struct nsh_vtbl_s *vtbl = dd->vtbl; |
| nsh_output(vtbl, g_fmtcmdfailed, g_dd, "open", NSH_ERRNO); |
| return ERROR; |
| } |
| |
| return OK; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: dd_outfopen |
| ****************************************************************************/ |
| |
| #ifndef CONFIG_DISABLE_MOUNTPOINT |
| static inline int dd_outfopen(const char *name, struct dd_s *dd) |
| { |
| int type; |
| int ret = OK; |
| |
| /* Get the type of the output file */ |
| |
| type = dd_filetype(name); |
| |
| /* Open the block driver for input */ |
| |
| if (type == true) |
| { |
| ret = bchlib_setup(name, true, &DD_OUTHANDLE); |
| if (ret < 0) |
| { |
| return ERROR; |
| } |
| |
| dd->outfwrite = dd_writeblk; /* Block oriented write */ |
| dd->outfclose = dd_outfcloseblk; |
| } |
| |
| /* Otherwise, the file is character oriented or does not exist */ |
| |
| else |
| { |
| DD_OUTFD = open(name, O_WRONLY|O_CREAT|O_TRUNC, 0644); |
| if (DD_OUTFD < 0) |
| { |
| FAR struct nsh_vtbl_s *vtbl = dd->vtbl; |
| nsh_output(vtbl, g_fmtcmdfailed, g_dd, "open", NSH_ERRNO); |
| return ERROR; |
| } |
| |
| dd->outfwrite = dd_writech; /* Character oriented write */ |
| dd->outfclose = dd_outfclosech; |
| } |
| |
| return OK; |
| } |
| #else |
| static inline int dd_outfopen(const char *name, struct dd_s *dd) |
| { |
| DD_OUTFD = open(name, O_WRONLY|O_CREAT|O_TRUNC, 0644); |
| if (DD_OUTFD < 0) |
| { |
| nsh_output(dd->vtbl, g_fmtcmdfailed, g_dd, "open", NSH_ERRNO); |
| return ERROR; |
| } |
| |
| return OK; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Public Functions |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Name: cmd_dd |
| ****************************************************************************/ |
| |
| int cmd_dd(FAR struct nsh_vtbl_s *vtbl, int argc, char **argv) |
| { |
| struct dd_s dd; |
| char *infile = NULL; |
| char *outfile = NULL; |
| int ret = ERROR; |
| int i; |
| |
| /* Initialize the dd structure */ |
| |
| memset(&dd, 0, sizeof(struct dd_s)); |
| dd.vtbl = vtbl; /* For nsh_output */ |
| dd.sectsize = DEFAULT_SECTSIZE; /* Sector size if 'bs=' not provided */ |
| dd.nsectors = 0xffffffff; /* MAX_UINT32 */ |
| |
| /* If no IF= option is provided on the command line, then read |
| * from stdin. |
| */ |
| |
| #ifdef CAN_PIPE_FROM_STD |
| DD_INFD = 0; /* stdin */ |
| #ifndef CONFIG_NSH_DISABLE_DD |
| dd.infread = readch; /* Character oriented read */ |
| dd.infclose = noclose; /* Don't close stdin */ |
| #endif |
| #endif |
| /* If no OF= option is provided on the command line, then write |
| * to stdout. |
| */ |
| |
| #ifdef CAN_PIPE_FROM_STD |
| DD_OUTDF = 1; /* stdout */ |
| #ifndef CONFIG_NSH_DISABLE_DD |
| dd.outfwrite = writech; /* Character oriented write */ |
| dd.outfclose = noclose; /* Don't close stdout */ |
| #endif |
| #endif |
| |
| /* Parse command line parameters */ |
| |
| for (i = 1; i < argc; i++) |
| { |
| if (strncmp(argv[i], "if=", 3) == 0) |
| { |
| infile = nsh_getfullpath(vtbl, &argv[i][3]); |
| } |
| else if (strncmp(argv[i], "of=", 3) == 0) |
| { |
| outfile = nsh_getfullpath(vtbl, &argv[i][3]); |
| } |
| else if (strncmp(argv[i], "bs=", 3) == 0) |
| { |
| dd.sectsize = atoi(&argv[i][3]); |
| } |
| else if (strncmp(argv[i], "count=", 6) == 0) |
| { |
| dd.nsectors = atoi(&argv[i][6]); |
| } |
| else if (strncmp(argv[i], "skip=", 5) == 0) |
| { |
| dd.skip = atoi(&argv[i][5]); |
| } |
| } |
| |
| #ifndef CAN_PIPE_FROM_STD |
| if (!infile || !outfile) |
| { |
| nsh_output(vtbl, g_fmtargrequired, g_dd); |
| goto errout_with_paths; |
| } |
| #endif |
| |
| /* Allocate the I/O buffer */ |
| |
| dd.buffer = malloc(dd.sectsize); |
| if (!dd.buffer) |
| { |
| nsh_output(vtbl, g_fmtcmdoutofmemory, g_dd); |
| goto errout_with_paths; |
| } |
| |
| /* Open the input file */ |
| |
| ret = dd_infopen(infile, &dd); |
| if (ret < 0) |
| { |
| goto errout_with_paths; |
| } |
| |
| /* Open the output file */ |
| |
| ret = dd_outfopen(outfile, &dd); |
| if (ret < 0) |
| { |
| goto errout_with_inf; |
| } |
| |
| /* Then perform the data transfer */ |
| |
| dd.sector = 0; |
| while (!dd.eof && dd.nsectors > 0) |
| { |
| /* Read one sector from from the input */ |
| |
| ret = DD_READ(&dd); |
| if (ret < 0) |
| { |
| goto errout_with_outf; |
| } |
| |
| /* Has the incoming data stream ended? */ |
| |
| if (!dd.eof) |
| { |
| /* Pad with zero if necessary (at the end of file only) */ |
| |
| for (i = dd.nbytes; i < dd.sectsize; i++) |
| { |
| dd.buffer[i] = 0; |
| } |
| |
| /* Write one sector to the output file */ |
| |
| if (dd.sector >= dd.skip) |
| { |
| ret = DD_WRITE(&dd); |
| if (ret < 0) |
| { |
| goto errout_with_outf; |
| } |
| |
| /* Decrement to show that a sector was written */ |
| |
| dd.nsectors--; |
| } |
| |
| /* Increment the sector number */ |
| |
| dd.sector++; |
| } |
| } |
| |
| ret = OK; |
| |
| errout_with_outf: |
| DD_INCLOSE(&dd); |
| |
| errout_with_inf: |
| DD_OUTCLOSE(&dd); |
| free(dd.buffer); |
| |
| errout_with_paths: |
| if (infile) |
| { |
| free(infile); |
| } |
| |
| if (outfile) |
| { |
| free(outfile); |
| } |
| |
| return ret; |
| } |
| |
| #endif /* CONFIG_NFILE_DESCRIPTORS && !CONFIG_NSH_DISABLE_DD */ |
| |