support ymodem send/recve can asynchronous

Signed-off-by: anjiahao <anjiahao@xiaomi.com>

system/ymodem/Kconfig

@@ -12,25 +12,23 @@ if SYSTEM_YMODEM
 
 config SYSTEM_YMODEM_STACKSIZE
 	int "ymodem stack size"
-	default 4096
+	default DEFAULT_TASK_STACKSIZE
 	---help---
 		The size of stack allocated for the ymodem task.
 
 config SYSTEM_YMODEM_PRIORITY
 	int "ymodem priority"
-	default 255
+	default 100
 	---help---
 		The priority of the ymodem task.
 
 config SYSTEM_YMODEM_DEBUG
 	bool "ymodem debug"
-	default false
+	default n
 
-if SYSTEM_YMODEM_DEBUG
+config SYSTEM_YMODEM_DEBUG_FILEPATH
-config SYSTEM_YMODEM_DEBUGFILE_PATH
 	string "save ymodem debug log path"
+	depends on SYSTEM_YMODEM_DEBUG
 	default "/tmp/ymodem"
 
 endif
-
-endif

system/ymodem/README.md

@@ -15,7 +15,7 @@ then use `<Ctrl + a> , r` chose `ymodem` to receive board file.
 
 ## Sendfile to board
 
-use rb cmd like this `nsh> sb`, this command support receive multiple files together
+use rb cmd like this `nsh> rb`, this command support receive multiple files together
 then use `<Ctrl + a> , s` chose `ymodem`, then chose what file need to send.
 
 ## help

system/ymodem/rb_main.c

@@ -25,117 +25,313 @@
 #include <fcntl.h>
 #include <stdio.h>
 #include <getopt.h>
-#include <nuttx/fs/ioctl.h>
+#include <pthread.h>
+
+#include <nuttx/mm/circbuf.h>
+
 #include "ymodem.h"
 
 /****************************************************************************
  * Private Types
  ****************************************************************************/
 
-struct ymodem_fd
+struct ymodem_priv_s
 {
-  int file_fd;
+  int fd;
-  char pathname[PATH_MAX];
+  FAR char *foldname;
   size_t file_saved_size;
-  char *removeperfix;
+  FAR char *skip_perfix;
-  char *removesuffix;
+  FAR char *skip_suffix;
+
+  /* Async */
+
+  struct circbuf_s circ;
+  pthread_mutex_t mutex;
+  pthread_cond_t cond;
+  size_t buffersize;
+  size_t threshold;
+  pthread_t pid;
+  bool exited;
 };
 
 /****************************************************************************
  * Private Functions
  ****************************************************************************/
 
-static int handler(FAR struct ymodem_ctx *ctx)
+static int flush_data(FAR struct ymodem_priv_s *priv)
 {
-  char pathname[PATH_MAX + YMODEM_FILE_NAME_LENGTH];
+  while (priv->fd > 0 && circbuf_used(&priv->circ))
-  FAR struct ymodem_fd *ym_fd = ctx->priv;
+    {
-  FAR char *filename;
+      FAR uint8_t *buffer;
+      size_t i = 0;
       size_t size;
-  size_t ret;
 
-  if (ctx->packet_type == YMODEM_FILE_RECV_NAME_PACKET)
+      buffer = circbuf_get_readptr(&priv->circ, &size);
+      while (i < size)
         {
-      if (ym_fd->file_fd != 0)
+          ssize_t ret = write(priv->fd, buffer + i, size - i);
-        {
+          if (ret < 0)
-          close(ym_fd->file_fd);
-        }
-
-      filename = ctx->file_name;
-      if (ym_fd->removeperfix)
-        {
-          if (strncmp(ctx->file_name, ym_fd->removeperfix,
-                      strlen(ym_fd->removeperfix)) == 0)
-            {
-              filename = filename + strlen(ym_fd->removeperfix);
-            }
-        }
-
-      if (ym_fd->removesuffix)
-        {
-          int len = strlen(filename);
-          if (len > strlen(ym_fd->removesuffix) &&
-              strcmp(filename + len - strlen(ym_fd->removesuffix),
-                     ym_fd->removesuffix) == 0)
-            {
-              filename[len - strlen(ym_fd->removesuffix)] = 0;
-            }
-        }
-
-      if (strlen(ym_fd->pathname) != 0)
-        {
-          sprintf(pathname, "%s/%s", ym_fd->pathname, filename);
-          filename = pathname;
-        }
-
-      ym_fd->file_fd = open(filename, O_CREAT | O_RDWR);
-      if (ym_fd->file_fd < 0)
             {
               return -errno;
             }
 
-      ym_fd->file_saved_size = 0;
+          i += ret;
         }
-  else if (ctx->packet_type == YMODEM_RECV_DATA_PACKET)
+
+      circbuf_readcommit(&priv->circ, size);
+    }
+
+  return 0;
+}
+
+static FAR void *async_write(FAR void *arg)
 {
-      if (ym_fd->file_saved_size + ctx->packet_size > ctx->file_length)
+  FAR struct ymodem_priv_s *priv = arg;
+
+  pthread_mutex_lock(&priv->mutex);
+  while (priv->exited == false)
     {
-          size = ctx->file_length - ym_fd->file_saved_size;
+      if (circbuf_used(&priv->circ) <= priv->threshold)
+        {
+          pthread_cond_wait(&priv->cond, &priv->mutex);
+          continue;
+        }
+
+      if (flush_data(priv) < 0)
+        {
+          pthread_mutex_unlock(&priv->mutex);
+          return NULL;
+        }
+    }
+
+  flush_data(priv);
+  pthread_mutex_unlock(&priv->mutex);
+  return NULL;
+}
+
+static int write_data(FAR struct ymodem_priv_s *priv,
+                      FAR const uint8_t *data, size_t size)
+{
+  size_t i = 0;
+
+  if (priv->buffersize)
+    {
+      pthread_mutex_lock(&priv->mutex);
+      while (i < size)
+        {
+          ssize_t ret = circbuf_write(&priv->circ, data + i, size - i);
+          if (ret < 0)
+            {
+              pthread_mutex_unlock(&priv->mutex);
+              return ret;
+            }
+          else if (ret == 0)
+            {
+              ret = flush_data(priv);
+              if (ret < 0)
+                {
+                  pthread_mutex_unlock(&priv->mutex);
+                  return ret;
+                }
+            }
+          else
+            {
+              i += ret;
+            }
+        }
+
+      if (circbuf_used(&priv->circ) > priv->threshold)
+        {
+          pthread_cond_signal(&priv->cond);
+        }
+
+      pthread_mutex_unlock(&priv->mutex);
+    }
+  else
+    {
+      while (i < size)
+        {
+          ssize_t ret = write(priv->fd, data + i, size - i);
+          if (ret < 0)
+            {
+              return -errno;
+            }
+
+          i += ret;
+        }
+    }
+
+  return 0;
+}
+
+static int handler(FAR struct ymodem_ctx_s *ctx)
+{
+  FAR struct ymodem_priv_s *priv = ctx->priv;
+  int ret;
+
+  if (ctx->packet_type == YMODEM_FILENAME_PACKET)
+    {
+      char temp[PATH_MAX];
+      FAR char *filename;
+
+      if (priv->fd > 0)
+        {
+          if (priv->buffersize)
+            {
+              pthread_mutex_lock(&priv->mutex);
+              ret = flush_data(priv);
+              pthread_mutex_unlock(&priv->mutex);
+              if (ret < 0)
+                {
+                  return ret;
+                }
+            }
+
+          close(priv->fd);
+        }
+
+      filename = ctx->file_name;
+      if (priv->skip_perfix != NULL)
+        {
+          size_t len = strlen(priv->skip_perfix);
+
+          if (strncmp(ctx->file_name, priv->skip_perfix,
+                      len) == 0)
+            {
+              filename += len;
+            }
+        }
+
+      if (priv->skip_suffix != NULL)
+        {
+          size_t len = strlen(filename);
+          size_t len2 = strlen(priv->skip_suffix);
+
+          if (len > len2 && strcmp(filename + len - len2,
+                                   priv->skip_suffix) == 0)
+            {
+              filename[len - len2] = '\0';
+            }
+        }
+
+      if (priv->foldname != NULL)
+        {
+          snprintf(temp, PATH_MAX, "%s/%s", priv->foldname,
+                   filename);
+          filename = temp;
+        }
+
+      priv->fd = open(filename, O_CREAT | O_WRONLY, 0777);
+      if (priv->fd < 0)
+        {
+          return -errno;
+        }
+
+      priv->file_saved_size = 0;
+    }
+  else if (ctx->packet_type == YMODEM_DATA_PACKET)
+    {
+      size_t size;
+
+      if (priv->file_saved_size + ctx->packet_size > ctx->file_length)
+        {
+          size = ctx->file_length - priv->file_saved_size;
         }
       else
         {
           size = ctx->packet_size;
         }
 
-      ret = write(ym_fd->file_fd, ctx->data, size);
+      ret = write_data(priv, ctx->data, size);
       if (ret < 0)
         {
-          return -errno;
+          return ret;
-        }
-      else if (ret < size)
-        {
-          return ERROR;
         }
 
-      ym_fd->file_saved_size += ret;
+      priv->file_saved_size += size;
     }
 
   return 0;
 }
 
-static void show_usage(FAR const char *progname, int errcode)
+static int async_init(FAR struct ymodem_priv_s *priv)
+{
+  int ret;
+
+  ret = circbuf_init(&priv->circ, NULL, priv->buffersize);
+  if (ret < 0)
+    {
+      fprintf(stderr, "ERROR: circbuf_init error\n");
+      return ret;
+    }
+
+  ret = pthread_mutex_init(&priv->mutex, NULL);
+  if (ret > 0)
+    {
+      fprintf(stderr, "ERROR: pthread_mutex_init error\n");
+      ret = -ret;
+      goto circ_err;
+    }
+
+  ret = pthread_cond_init(&priv->cond, NULL);
+  if (ret > 0)
+    {
+      fprintf(stderr, "ERROR: pthread_cond_init error\n");
+      ret = -ret;
+      goto mutex_err;
+    }
+
+  ret = pthread_create(&priv->pid, NULL, async_write, priv);
+  if (ret > 0)
+    {
+      ret = -ret;
+      goto cond_err;
+    }
+
+  return ret;
+cond_err:
+  pthread_cond_destroy(&priv->cond);
+mutex_err:
+  pthread_mutex_destroy(&priv->mutex);
+circ_err:
+  circbuf_uninit(&priv->circ);
+  return ret;
+}
+
+static void async_uninit(FAR struct ymodem_priv_s *priv)
+{
+  pthread_mutex_lock(&priv->mutex);
+  priv->exited = true;
+  pthread_cond_signal(&priv->cond);
+  pthread_mutex_unlock(&priv->mutex);
+  pthread_join(priv->pid, NULL);
+  pthread_cond_destroy(&priv->cond);
+  pthread_mutex_destroy(&priv->mutex);
+  circbuf_uninit(&priv->circ);
+}
+
+static void show_usage(FAR const char *progname)
 {
   fprintf(stderr, "USAGE: %s [OPTIONS]\n", progname);
   fprintf(stderr, "\nWhere:\n");
   fprintf(stderr, "\nand OPTIONS include the following:\n");
   fprintf(stderr,
-    "\t-d <device>: Communication device to use. Default: stdin & stdout\n");
+          "\t-d <device>: Communication device to use."
+           "Default: stdin & stdout\n");
   fprintf(stderr,
-          "\t-p <path>: Save remote file path. Default: Current path\n");
+          "\t-f <foldname>: Save remote file fold. Default: Current fold\n");
   fprintf(stderr,
-          "\t--removeprefix <prefix>: Remove save file name prefix\n");
+          "\t-p|--skip_prefix <prefix>: Remove file name prefix\n");
   fprintf(stderr,
-          "\t--removesuffix <suffix>: Remove save file name suffix\n");
+          "\t-s|--skip_suffix <suffix>: Remove file name suffix\n");
-  exit(errcode);
+  fprintf(stderr,
+          "\t-b|--buffersize <size>: Asynchronously receive buffer size."
+          "If greater than 0, accept data asynchronously, Default: 0kB\n");
+  fprintf(stderr,
+          "\t-t|--threshold <size>: Threshold for writing asynchronously."
+          "Threshold must be less than or equal buffersize, Default: 0kB\n");
+
+  exit(EXIT_FAILURE);
 }
 
 /****************************************************************************
@@ -144,72 +340,108 @@ static void show_usage(FAR const char *progname, int errcode)
 
 int main(int argc, FAR char *argv[])
 {
-  struct ymodem_fd ym_fd;
+  struct ymodem_priv_s priv;
-  struct ymodem_ctx ctx;
+  struct ymodem_ctx_s ctx;
-  int index;
+  FAR char *devname = NULL;
   int ret;
+
   struct option options[] =
     {
-      {"removeprefix", 1, NULL, 1},
+      {"buffersize", 1, NULL, 'b'},
-      {"removesuffix", 1, NULL, 2},
+      {"skip_prefix", 1, NULL, 'p'},
+      {"skip_suffix", 1, NULL, 's'},
+      {"threshold", 1, NULL, 't'}
     };
 
-  memset(&ym_fd, 0, sizeof(struct ymodem_fd));
+  memset(&priv, 0, sizeof(priv));
-  memset(&ctx, 0, sizeof(struct ymodem_ctx));
+  memset(&ctx, 0, sizeof(ctx));
-  ctx.packet_handler = handler;
+  while ((ret = getopt_long(argc, argv, "b:d:f:hp:s:t:", options, NULL))
-  ctx.timeout = 200;
-  ctx.priv = &ym_fd;
-  ctx.recvfd = 0;
-  ctx.sendfd = 1;
-  while ((ret = getopt_long(argc, argv, "p:d:h", options, &index))
          != ERROR)
     {
       switch (ret)
         {
-          case 1:
+          case 'b':
-            ym_fd.removeperfix = optarg;
+            priv.buffersize = atoi(optarg) * 1024;
             break;
-          case 2:
+          case 'd':
-            ym_fd.removesuffix = optarg;
+            devname = optarg;
             break;
-          case 'p':
+          case 'f':
-            strlcpy(ym_fd.pathname, optarg, PATH_MAX);
+            priv.foldname = optarg;
-            if (ym_fd.pathname[strlen(ym_fd.pathname)] == '/')
+            if (priv.foldname[strlen(priv.foldname)] == '/')
               {
-                ym_fd.pathname[strlen(ym_fd.pathname)] = 0;
+                priv.foldname[strlen(priv.foldname)] = '\0';
               }
 
             break;
-          case 'd':
+          case 'h':
-            ctx.recvfd = open(optarg, O_RDWR | O_NONBLOCK);
+            show_usage(argv[0]);
+            break;
+          case 'p':
+            priv.skip_perfix = optarg;
+            break;
+          case 's':
+            priv.skip_suffix = optarg;
+            break;
+          case 't':
+            priv.threshold = atoi(optarg) * 1024;
+            break;
+
+          default:
+            show_usage(argv[0]);
+            break;
+        }
+    }
+
+  if (priv.threshold > priv.buffersize)
+    {
+      show_usage(argv[0]);
+    }
+
+  if (priv.buffersize)
+    {
+      ret = async_init(&priv);
+      if (ret < 0)
+        {
+          return ret;
+        }
+    }
+
+  ctx.packet_handler = handler;
+  ctx.priv = &priv;
+  if (devname)
+    {
+      ctx.recvfd = open(devname, O_RDWR);
       if (ctx.recvfd < 0)
         {
-                fprintf(stderr, "ERROR: can't open %s\n", optarg);
+          fprintf(stderr, "ERROR: can't open %s\n", devname);
+          goto out;
         }
 
         ctx.sendfd = ctx.recvfd;
-            break;
-          case 'h':
-            show_usage(argv[0], EXIT_FAILURE);
-            break;
-          default:
-          case '?':
-            fprintf(stderr, "ERROR: Unrecognized option\n");
-            show_usage(argv[0], EXIT_FAILURE);
-            break;
     }
+  else
+    {
+      ctx.recvfd = STDIN_FILENO;
+      ctx.sendfd = STDOUT_FILENO;
     }
 
-  ymodem_recv(&ctx);
+  ret = ymodem_recv(&ctx);
-  if (ctx.recvfd)
+  if (ctx.recvfd > 0)
     {
       close(ctx.recvfd);
     }
 
-  if (ym_fd.file_fd)
+out:
+  if (priv.buffersize)
     {
-      close(ym_fd.file_fd);
+      async_uninit(&priv);
     }
 
-  return 0;
+  if (priv.fd > 0)
+    {
+      close(priv.fd);
+    }
+
+  return ret;
 }

system/ymodem/sb_main.c

@@ -23,72 +23,247 @@
  ****************************************************************************/
 
 #include <fcntl.h>
-#include <libgen.h>
 #include <stdio.h>
-#include <termios.h>
+#include <getopt.h>
+#include <libgen.h>
+#include <pthread.h>
 #include <sys/stat.h>
 
+#include <nuttx/mm/circbuf.h>
+
 #include "ymodem.h"
 
 /****************************************************************************
- * Private Functions
+ * Private Type Definitions
  ****************************************************************************/
 
-struct ymodem_fd
+struct ymodem_priv_s
 {
-  int file_fd;
+  int fd;
   FAR char **filelist;
   size_t filenum;
+
+  /* Async */
+
+  struct circbuf_s circ;
+  pthread_mutex_t mutex;
+  pthread_cond_t cond;
+  size_t buffersize;
+  pthread_t pid;
+  bool exited;
 };
 
 /****************************************************************************
  * Private Functions
  ****************************************************************************/
 
-static ssize_t handler(FAR struct ymodem_ctx *ctx)
+static FAR void *async_read(FAR void *arg)
 {
-  FAR struct ymodem_fd *ym_fd = ctx->priv;
+  FAR struct ymodem_priv_s *priv = arg;
-  ssize_t ret = -EINVAL;
-  FAR char *filename;
-  struct stat info;
 
-  if (ctx->packet_type == YMODEM_FILE_SEND_NAME_PACKET)
+  pthread_mutex_lock(&priv->mutex);
+  while (priv->exited == false)
     {
-      if (ym_fd->file_fd != 0)
+      FAR uint8_t *buffer;
-        {
+      ssize_t ret = 0;
-          close(ym_fd->file_fd);
+      size_t size;
-        }
 
-      filename = ym_fd->filelist[ym_fd->filenum++];
+      if (priv->fd > 0)
-      ret = lstat(filename, &info);
+        {
+          buffer = circbuf_get_writeptr(&priv->circ, &size);
+          ret = read(priv->fd, buffer, size);
           if (ret < 0)
             {
+              break;
+            }
+
+          circbuf_writecommit(&priv->circ, ret);
+        }
+
+      if (circbuf_is_full(&priv->circ) || priv->fd <= 0 || ret == 0)
+        {
+          pthread_cond_wait(&priv->cond, &priv->mutex);
+        }
+    }
+
+  pthread_mutex_unlock(&priv->mutex);
+  return NULL;
+}
+
+static int read_data(FAR struct ymodem_priv_s *priv,
+                     FAR uint8_t *data, size_t size)
+{
+  ssize_t i = 0;
+
+  if (priv->buffersize)
+    {
+      pthread_mutex_lock(&priv->mutex);
+      while (i < size)
+        {
+          ssize_t ret = circbuf_read(&priv->circ, data + i, size - i);
+
+          if (ret < 0)
+            {
+              pthread_mutex_unlock(&priv->mutex);
               return ret;
             }
 
-      ym_fd->file_fd = open(filename, O_RDWR);
+          if (ret == 0)
-      if (ym_fd->file_fd < 0)
             {
-          return ym_fd->file_fd;
+              ret = read(priv->fd, data + i, size - i);
+              if (ret < 0)
+                {
+                  pthread_mutex_unlock(&priv->mutex);
+                  return -errno;
+                }
+            }
+
+          i += ret;
+        }
+
+      pthread_cond_signal(&priv->cond);
+      pthread_mutex_unlock(&priv->mutex);
+    }
+  else
+    {
+      while (i < size)
+        {
+          ssize_t ret = read(priv->fd, data + i, size - i);
+
+          if (ret < 0)
+            {
+              return -errno;
+            }
+
+          i += ret;
+        }
+    }
+
+  return 0;
+}
+
+static int handler(FAR struct ymodem_ctx_s *ctx)
+{
+  FAR struct ymodem_priv_s *priv = ctx->priv;
+  int ret;
+
+  if (ctx->packet_type == YMODEM_FILENAME_PACKET)
+    {
+      FAR char *filename;
+      struct stat st;
+
+      if (priv->fd > 0)
+        {
+          close(priv->fd);
+          priv->fd = 0;
+        }
+
+      filename = priv->filelist[priv->filenum++];
+      if (filename == NULL)
+        {
+          return -ENOENT;
+        }
+
+      ret = stat(filename, &st);
+      if (ret < 0)
+        {
+          return -errno;
+        }
+
+      priv->fd = open(filename, O_RDONLY);
+      if (priv->fd < 0)
+        {
+          return -errno;
         }
 
       filename = basename(filename);
-      strncpy(ctx->file_name, filename, YMODEM_FILE_NAME_LENGTH);
+      strlcpy(ctx->file_name, filename, PATH_MAX);
-      ctx->file_length = info.st_size;
+      ctx->file_length = st.st_size;
     }
-  else if (ctx->packet_type == YMODEM_SEND_DATA_PACKET)
+  else if (ctx->packet_type == YMODEM_DATA_PACKET)
     {
-      ret = read(ym_fd->file_fd, ctx->data, ctx->packet_size);
+      size_t size;
+
+      if (ctx->file_length > ctx->packet_size)
+        {
+          size = ctx->packet_size;
+        }
+      else
+        {
+          size = ctx->file_length;
+          memset(ctx->data + size, 0x1a,
+                 ctx->packet_size - ctx->file_length);
+        }
+
+      ret = read_data(priv, ctx->data, size);
       if (ret < 0)
         {
           return ret;
         }
+
+      ctx->file_length -= size;
     }
 
+  return 0;
+}
+
+static int async_init(FAR struct ymodem_priv_s *priv)
+{
+  int ret;
+
+  ret = circbuf_init(&priv->circ, NULL, priv->buffersize);
+  if (ret < 0)
+    {
+      fprintf(stderr, "ERROR: circbuf_init error\n");
       return ret;
     }
 
-static void show_usage(FAR const char *progname, int errcode)
+  ret = pthread_mutex_init(&priv->mutex, NULL);
+  if (ret > 0)
+    {
+      fprintf(stderr, "ERROR: pthread_mutex_init error\n");
+      ret = -ret;
+      goto circ_err;
+    }
+
+  ret = pthread_cond_init(&priv->cond, NULL);
+  if (ret > 0)
+    {
+      fprintf(stderr, "ERROR: pthread_cond_init error\n");
+      ret = -ret;
+      goto mutex_err;
+    }
+
+  ret = pthread_create(&priv->pid, NULL, async_read, priv);
+  if (ret < 0)
+    {
+      ret = -ret;
+      goto cond_err;
+    }
+
+  return ret;
+cond_err:
+  pthread_cond_destroy(&priv->cond);
+mutex_err:
+  pthread_mutex_destroy(&priv->mutex);
+circ_err:
+  circbuf_uninit(&priv->circ);
+  return ret;
+}
+
+static void async_uninit(FAR struct ymodem_priv_s *priv)
+{
+  pthread_mutex_lock(&priv->mutex);
+  priv->exited = true;
+  pthread_cond_signal(&priv->cond);
+  pthread_mutex_unlock(&priv->mutex);
+  pthread_join(priv->pid, NULL);
+  pthread_cond_destroy(&priv->cond);
+  pthread_mutex_destroy(&priv->mutex);
+  circbuf_uninit(&priv->circ);
+}
+
+static void show_usage(FAR const char *progname)
 {
   fprintf(stderr, "USAGE: %s [OPTIONS] <lname> [<lname> [<lname> ...]]\n",
                   progname);
@@ -97,8 +272,10 @@ static void show_usage(FAR const char *progname, int errcode)
   fprintf(stderr, "\nand OPTIONS include the following:\n");
   fprintf(stderr,
     "\t-d <device>: Communication device to use. Default: stdin & stdout\n");
-
+  fprintf(stderr,
-  exit(errcode);
+          "\t-b|--buffersize <size>: Asynchronously send buffer size."
+          "If greater than 0, accept data asynchronously, Default: 0kB\n");
+  exit(EXIT_FAILURE);
 }
 
 /****************************************************************************
@@ -107,56 +284,82 @@ static void show_usage(FAR const char *progname, int errcode)
 
 int main(int argc, FAR char *argv[])
 {
-  struct ymodem_fd ym_fd;
+  struct ymodem_priv_s priv;
-  struct ymodem_ctx ctx;
+  struct ymodem_ctx_s ctx;
-  int option;
+  FAR char *devname = NULL;
+  int ret = 0;
+  struct option options[] =
+    {
+      {"buffersize", 1, NULL, 'b'},
+    };
 
-  memset(&ctx, 0, sizeof(struct ymodem_ctx));
+  memset(&priv, 0, sizeof(priv));
-  ctx.packet_handler = handler;
+  memset(&ctx, 0, sizeof(ctx));
-  ctx.timeout = 3000;
+  while ((ret = getopt_long(argc, argv, "b:d:h", options, NULL))
-  ctx.recvfd = 0;
+         != ERROR)
-  ctx.sendfd = 1;
-  ctx.priv = &ym_fd;
-  while ((option = getopt(argc, argv, "d:h")) != ERROR)
     {
-      switch (option)
+      switch (ret)
         {
+          case 'b':
+            priv.buffersize = atoi(optarg) * 1024;
+            break;
           case 'd':
-            ctx.recvfd = open(optarg, O_RDWR);
+            devname = optarg;
+            break;
+          case 'h':
+          case '?':
+          default:
+            show_usage(argv[0]);
+            break;
+        }
+    }
+
+  ctx.packet_handler = handler;
+  if (devname)
+    {
+      ctx.recvfd = open(devname, O_RDWR);
       if (ctx.recvfd < 0)
         {
-                fprintf(stderr, "ERROR: can't open %s\n", optarg);
+          fprintf(stderr, "ERROR: can't open %s\n", devname);
+          return -errno;
         }
 
         ctx.sendfd = ctx.recvfd;
-            break;
+    }
+  else
+    {
+      ctx.recvfd = STDIN_FILENO;
+      ctx.sendfd = STDOUT_FILENO;
+    }
 
-          case 'h':
+  ctx.priv = &priv;
-            show_usage(argv[0], EXIT_FAILURE);
+  priv.filelist = &argv[optind];
-
+  if (priv.buffersize)
-          default:
+    {
-          case '?':
+      ret = async_init(&priv);
-            fprintf(stderr, "ERROR: Unrecognized option\n");
+      if (ret < 0)
-            show_usage(argv[0], EXIT_FAILURE);
+        {
-            break;
+          goto out;
         }
     }
 
-  ctx.need_sendfile_num = argc - optind;
+  ret = ymodem_send(&ctx);
-  ym_fd.file_fd = 0;
-  ym_fd.filelist = &argv[optind];
-  ym_fd.filenum = 0;
 
-  ymodem_send(&ctx);
+  if (priv.buffersize)
-  if (ctx.recvfd)
+    {
+      async_uninit(&priv);
+    }
+
+out:
+  if (priv.fd > 0)
+    {
+      close(priv.fd);
+    }
+
+  if (ctx.recvfd > 0)
     {
       close(ctx.recvfd);
     }
 
-  if (ym_fd.file_fd)
+  return ret;
-    {
-      close(ym_fd.file_fd);
-    }
-
-  return 0;
 }

system/ymodem/ymodem.h

@@ -25,48 +25,43 @@
  * Included Files
  ****************************************************************************/
 
-#include <stdint.h>
+#include <stddef.h>
-#include <stdlib.h>
 
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/
 
-#ifdef CONFIG_SYSTEM_YMODEM_DEBUGFILE_PATH
-#  define ymodem_debug(...) dprintf(ctx->debug_fd, ##__VA_ARGS__)
-#else
-#  define ymodem_debug(...)
-#endif
-
 #define YMODEM_PACKET_SIZE               128
 #define YMODEM_PACKET_1K_SIZE            1024
-#define YMODEM_FILE_NAME_LENGTH          64
 
-#define YMODEM_FILE_RECV_NAME_PACKET        0
+#define YMODEM_FILENAME_PACKET           0
-#define YMODEM_RECV_DATA_PACKET             1
+#define YMODEM_DATA_PACKET               1
-#define YMODEM_FILE_SEND_NAME_PACKET        2
-#define YMODEM_SEND_DATA_PACKET             3
 
 /****************************************************************************
  * Public Types
  ****************************************************************************/
 
-struct ymodem_ctx
+struct ymodem_ctx_s
 {
-  uint8_t header;
+  /* User need initialization */
-  uint8_t seq[2];
+
-  uint8_t data[YMODEM_PACKET_1K_SIZE];
-  char file_name[YMODEM_FILE_NAME_LENGTH];
-  uint16_t packet_size;
-  uint32_t file_length;
-  uint32_t timeout;
-  uint32_t packet_type;
   int recvfd;
   int sendfd;
-  CODE ssize_t (*packet_handler)(FAR struct ymodem_ctx *ctx);
+  CODE int (*packet_handler)(FAR struct ymodem_ctx_s *ctx);
   FAR void *priv;
-  uint16_t need_sendfile_num;
+
-#ifdef CONFIG_SYSTEM_YMODEM_DEBUGFILE_PATH
+  /* Public data */
+
+  FAR uint8_t *data;
+  size_t packet_size;
+  int packet_type;
+  char file_name[PATH_MAX];
+  size_t file_length;
+
+  /* Private data */
+
+  FAR uint8_t *header;
+#ifdef CONFIG_SYSTEM_YMODEM_DEBUG_FILEPATH
   int debug_fd;
 #endif
 };
@@ -75,7 +70,7 @@ struct ymodem_ctx
  * Public Function Prototypes
  ****************************************************************************/
 
-int ymodem_recv(FAR struct ymodem_ctx *ctx);
+int ymodem_recv(FAR struct ymodem_ctx_s *ctx);
-int ymodem_send(FAR struct ymodem_ctx *ctx);
+int ymodem_send(FAR struct ymodem_ctx_s *ctx);
 
 #endif /* __APPS_SYSTEM_YMODEM_YMODEM_H */