/****************************************************************************
 * libs/libc/userfs/lib_userfs.c
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <nuttx/config.h>

#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/socket.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>

#include <arpa/inet.h>
#include <netinet/in.h>

#include <nuttx/fs/userfs.h>
#include <nuttx/mutex.h>

#include "libc.h"

/****************************************************************************
 * Private Types
 ****************************************************************************/

struct userfs_info_s
{
  FAR const struct userfs_operations_s *userops;
  FAR void *volinfo;          /* Data that accompanies the user callbacks */
  struct sockaddr_in client;  /* Client to send response back to */
  int16_t sockfd;             /* Server socket */
  uint16_t iolen;             /* Size of I/O buffer */
  uint16_t mxwrite;           /* The max size of a write data */
  uint8_t iobuffer[1];        /* I/O buffer.  Actual size is iolen. */
};

#define SIZEOF_USERFS_INFO_S(n) (sizeof(struct userfs_info_s) + (n) - 1)

/****************************************************************************
 * Private Data
 ****************************************************************************/

/* REVISIT:  This is insufficient in the KERNEL build.  In that build mode,
 * there will be multiple instances of these variables and the logic will
 * not generate unique instance numbers.
 */

static mutex_t g_userfs_lock = NXMUTEX_INITIALIZER;
static uint8_t g_userfs_next_instance;

/****************************************************************************
 * Private Functions
 ****************************************************************************/

/****************************************************************************
 * Name: userfs_server_portno
 ****************************************************************************/

static inline uint16_t userfs_server_portno(void)
{
  int ret;

  ret = nxmutex_lock(&g_userfs_lock);
  if (ret >= 0)
    {
      /* Get the next instance number.
       *
       * REVISIT: Here we really should verify that other UserFs
       * exists with the same instance number.  That could
       * happen if g_userfs_next_instance were to wrap around.
       */

      ret = USERFS_SERVER_PORTBASE | g_userfs_next_instance++;
      nxmutex_unlock(&g_userfs_lock);
    }

  return ret;
}

/****************************************************************************
 * Name: userfs_*_dispatch
 ****************************************************************************/

static inline int userfs_open_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_open_request_s *req, size_t reqlen)
{
  struct userfs_open_response_s resp;
  int pathlen;
  size_t expected;
  ssize_t nsent;
  int ret;

  /* Verify the request size */

  if (reqlen < SIZEOF_USERFS_OPEN_REQUEST_S(0))
    {
      return -EINVAL;
    }

  pathlen = strlen(req->relpath);
  if (pathlen > info->mxwrite)
    {
      return -EINVAL;
    }

  expected = SIZEOF_USERFS_OPEN_REQUEST_S(pathlen);
  if (expected >= reqlen)
    {
      return -EINVAL;
    }

  /* Dispatch the request.
   *
   * REVISIT: In the kernel build openinfo will be valid only in the
   * context of this process.
   */

  DEBUGASSERT(info->userops != NULL && info->userops->open != NULL);
  resp.ret  = info->userops->open(info->volinfo, req->relpath, req->oflags,
                                  req->mode, &resp.openinfo);

  /* Send the response */

  resp.resp = USERFS_RESP_OPEN;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_open_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  if (nsent < 0)
    {
      ret = -get_errno();
      ferr("ERROR: Send open response failed: %d\n", ret);
      return ret;
    }

  /* REVISIT: Partial sends are not supported */

  DEBUGASSERT(nsent == sizeof(struct userfs_open_response_s));
  return OK;
}

static inline int userfs_close_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_close_request_s *req, size_t reqlen)
{
  struct userfs_close_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_close_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->close != NULL);
  resp.ret  = info->userops->close(info->volinfo, req->openinfo);

  /* Send the response */

  resp.resp = USERFS_RESP_CLOSE;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_close_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_read_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_read_request_s *req, size_t reqlen)
{
  FAR struct userfs_read_response_s *resp;
  size_t readlen;
  size_t resplen;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_read_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  readlen = req->readlen;
  if (readlen > info->mxwrite)
    {
      readlen = info->mxwrite;
    }

  resp = (FAR struct userfs_read_response_s *)info->iobuffer;

  DEBUGASSERT(info->userops != NULL && info->userops->read != NULL);
  resp->nread = info->userops->read(info->volinfo, req->openinfo,
                                    resp->rddata, readlen);

  /* Send the response */

  resp->resp  = USERFS_RESP_READ;
  resplen     = SIZEOF_USERFS_READ_RESPONSE_S(resp->nread);
  nsent       = sendto(info->sockfd, resp, resplen, 0,
                       (FAR struct sockaddr *)&info->client,
                       sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_write_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_write_request_s *req, size_t reqlen)
{
  struct userfs_write_response_s resp;
  size_t writelen;
  size_t expected;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen < SIZEOF_USERFS_WRITE_REQUEST_S(0))
    {
      return -EINVAL;
    }

  writelen = req->writelen;
  if (writelen > info->mxwrite)
    {
      return -EINVAL;
    }

  expected = SIZEOF_USERFS_WRITE_REQUEST_S(writelen);
  if (expected != reqlen)
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->write != NULL);
  resp.nwritten = info->userops->write(info->volinfo, req->openinfo,
                                       req->wrdata, writelen);

  /* Send the response */

  resp.resp     = USERFS_RESP_WRITE;
  nsent         = sendto(info->sockfd, &resp,
                         sizeof(struct userfs_write_response_s),
                         0, (FAR struct sockaddr *)&info->client,
                         sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_seek_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_seek_request_s *req, size_t reqlen)
{
  struct userfs_seek_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_seek_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->seek != NULL);
  resp.ret  = info->userops->seek(info->volinfo, req->openinfo, req->offset,
                                  req->whence);

  /* Send the response */

  resp.resp = USERFS_RESP_SEEK;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_seek_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_ioctl_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_ioctl_request_s *req, size_t reqlen)
{
  struct userfs_ioctl_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_ioctl_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->ioctl != NULL);
  resp.ret  = info->userops->ioctl(info->volinfo, req->openinfo, req->cmd,
                                   req->arg);

  /* Send the response */

  resp.resp = USERFS_RESP_IOCTL;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_ioctl_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_sync_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_sync_request_s *req, size_t reqlen)
{
  struct userfs_sync_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_sync_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->sync != NULL);
  resp.ret  = info->userops->sync(info->volinfo, req->openinfo);

  /* Send the response */

  resp.resp = USERFS_RESP_SYNC;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_sync_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_dup_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_dup_request_s *req, size_t reqlen)
{
  struct userfs_dup_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_dup_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->dup != NULL);
  resp.ret  = info->userops->dup(info->volinfo,
                                 req->openinfo, &resp.openinfo);

  /* Send the response */

  resp.resp = USERFS_RESP_DUP;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_dup_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_fstat_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_fstat_request_s *req, size_t reqlen)
{
  struct userfs_fstat_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_fstat_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->fstat != NULL);
  resp.ret  = info->userops->fstat(info->volinfo, req->openinfo, &resp.buf);

  /* Send the response */

  resp.resp = USERFS_RESP_FSTAT;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_fstat_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_truncate_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_truncate_request_s *req, size_t reqlen)
{
  struct userfs_truncate_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_truncate_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->truncate != NULL);
  resp.ret  = info->userops->truncate(info->volinfo,
                                      req->openinfo, req->length);

  /* Send the response */

  resp.resp = USERFS_RESP_FSTAT;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_truncate_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_opendir_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_opendir_request_s *req, size_t reqlen)
{
  struct userfs_opendir_response_s resp;
  int pathlen;
  size_t expected;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen < SIZEOF_USERFS_OPENDIR_REQUEST_S(0))
    {
      return -EINVAL;
    }

  pathlen = strlen(req->relpath);
  if (pathlen > info->mxwrite)
    {
      return -EINVAL;
    }

  expected = SIZEOF_USERFS_OPENDIR_REQUEST_S(pathlen);
  if (expected >= reqlen)
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->opendir != NULL);
  resp.ret  = info->userops->opendir(info->volinfo, req->relpath, &resp.dir);

  /* Send the response */

  resp.resp = USERFS_RESP_OPENDIR;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_opendir_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_closedir_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_closedir_request_s *req, size_t reqlen)
{
  struct userfs_closedir_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_closedir_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->closedir != NULL);
  resp.ret  = info->userops->closedir(info->volinfo, req->dir);

  /* Send the response */

  resp.resp = USERFS_RESP_CLOSEDIR;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_closedir_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_readdir_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_readdir_request_s *req, size_t reqlen)
{
  struct userfs_readdir_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_readdir_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->readdir != NULL);
  resp.ret  = info->userops->readdir(info->volinfo, req->dir, &resp.entry);

  /* Send the response */

  resp.resp = USERFS_RESP_READDIR;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_readdir_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_rewinddir_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_rewinddir_request_s *req, size_t reqlen)
{
  struct userfs_rewinddir_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_rewinddir_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->rewinddir != NULL);
  resp.ret  = info->userops->rewinddir(info->volinfo, req->dir);

  /* Send the response */

  resp.resp = USERFS_RESP_REWINDDIR;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_rewinddir_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_statfs_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_statfs_request_s *req, size_t reqlen)
{
  struct userfs_statfs_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_statfs_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->statfs != NULL);
  memset(&resp.buf, 0, sizeof(struct statfs));
  resp.ret  = info->userops->statfs(info->volinfo, &resp.buf);

  /* Send the response */

  resp.resp = USERFS_RESP_STATFS;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_statfs_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_unlink_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_unlink_request_s *req, size_t reqlen)
{
  struct userfs_unlink_response_s resp;
  int pathlen;
  size_t expected;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen < SIZEOF_USERFS_UNLINK_REQUEST_S(0))
    {
      return -EINVAL;
    }

  pathlen = strlen(req->relpath);
  if (pathlen > info->mxwrite)
    {
      return -EINVAL;
    }

  expected = SIZEOF_USERFS_UNLINK_REQUEST_S(pathlen);
  if (expected >= reqlen)
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->unlink != NULL);
  resp.ret  = info->userops->unlink(info->volinfo, req->relpath);

  /* Send the response */

  resp.resp = USERFS_RESP_UNLINK;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_unlink_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_mkdir_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_mkdir_request_s *req, size_t reqlen)
{
  struct userfs_mkdir_response_s resp;
  int pathlen;
  size_t expected;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen < SIZEOF_USERFS_MKDIR_REQUEST_S(0))
    {
      return -EINVAL;
    }

  pathlen = strlen(req->relpath);
  if (pathlen > info->mxwrite)
    {
      return -EINVAL;
    }

  expected = SIZEOF_USERFS_MKDIR_REQUEST_S(pathlen);
  if (expected >= reqlen)
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->mkdir != NULL);
  resp.ret  = info->userops->mkdir(info->volinfo, req->relpath, req->mode);

  /* Send the response */

  resp.resp = USERFS_RESP_MKDIR;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_mkdir_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_rmdir_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_rmdir_request_s *req, size_t reqlen)
{
  struct userfs_rmdir_response_s resp;
  int pathlen;
  size_t expected;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen < SIZEOF_USERFS_MKDIR_REQUEST_S(0))
    {
      return -EINVAL;
    }

  pathlen = strlen(req->relpath);
  if (pathlen > info->mxwrite)
    {
      return -EINVAL;
    }

  expected = SIZEOF_USERFS_MKDIR_REQUEST_S(pathlen);
  if (expected >= reqlen)
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->rmdir != NULL);
  resp.ret  = info->userops->rmdir(info->volinfo, req->relpath);

  /* Send the response */

  resp.resp = USERFS_RESP_RMDIR;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_rmdir_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_rename_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_rename_request_s *req, size_t reqlen)
{
  struct userfs_rename_response_s resp;
  FAR char *newrelpath;
  unsigned int newoffset;
  int oldpathlen;
  int newpathlen;
  size_t expected;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen < SIZEOF_USERFS_RENAME_REQUEST_S(0, 0))
    {
      return -EINVAL;
    }

  oldpathlen = strlen(req->oldrelpath);
  newoffset  = req->newoffset;

  if (oldpathlen >= newoffset)
    {
      return -EINVAL;
    }

  newrelpath = &req->oldrelpath[newoffset];
  newpathlen = strlen(newrelpath);

  if ((newpathlen + newoffset) > info->mxwrite)
    {
      return -EINVAL;
    }

  expected = SIZEOF_USERFS_RENAME_REQUEST_S(newoffset, newpathlen);
  if (expected >= reqlen)
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->rename != NULL);
  resp.ret  = info->userops->rename(info->volinfo, req->oldrelpath,
                                    newrelpath);

  /* Send the response */

  resp.resp = USERFS_RESP_RENAME;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_rename_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_stat_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_stat_request_s *req, size_t reqlen)
{
  struct userfs_stat_response_s resp;
  int pathlen;
  size_t expected;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen < SIZEOF_USERFS_STAT_REQUEST_S(0))
    {
      return -EINVAL;
    }

  pathlen = strlen(req->relpath);
  if (pathlen > info->mxwrite)
    {
      return -EINVAL;
    }

  expected = SIZEOF_USERFS_STAT_REQUEST_S(pathlen);
  if (expected >= reqlen)
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->stat != NULL);
  resp.ret  = info->userops->stat(info->volinfo, req->relpath, &resp.buf);

  /* Send the response */

  resp.resp = USERFS_RESP_STAT;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_stat_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_destroy_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_destroy_request_s *req, size_t reqlen)
{
  struct userfs_destroy_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_destroy_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->destroy != NULL);
  resp.ret  = info->userops->destroy(info->volinfo);

  /* Send the response */

  resp.resp = USERFS_RESP_DESTROY;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_destroy_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  if (nsent < 0)
    {
      int ret = -get_errno();
      ferr("ERROR: sendto failed: %d\n", ret);
      return ret;
    }

  /* Speical case of resp.ret indicates an error, the destruction was
   * refused.  So we need to return success in this case so that we
   * continue processing requests.
   */

  return resp.ret < 0 ? OK : -ENOTCONN;
}

static inline int userfs_fchstat_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_fchstat_request_s *req, size_t reqlen)
{
  struct userfs_fchstat_response_s resp;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen != sizeof(struct userfs_fchstat_request_s))
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->fchstat != NULL);
  resp.ret  = info->userops->fchstat(info->volinfo, req->openinfo,
                                     &req->buf, req->flags);

  /* Send the response */

  resp.resp = USERFS_RESP_FCHSTAT;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_fchstat_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

static inline int userfs_chstat_dispatch(FAR struct userfs_info_s *info,
                   FAR struct userfs_chstat_request_s *req, size_t reqlen)
{
  struct userfs_chstat_response_s resp;
  int pathlen;
  size_t expected;
  ssize_t nsent;

  /* Verify the request size */

  if (reqlen < SIZEOF_USERFS_CHSTAT_REQUEST_S(0))
    {
      return -EINVAL;
    }

  pathlen = strlen(req->relpath);
  if (pathlen > info->mxwrite)
    {
      return -EINVAL;
    }

  expected = SIZEOF_USERFS_CHSTAT_REQUEST_S(pathlen);
  if (expected >= reqlen)
    {
      return -EINVAL;
    }

  /* Dispatch the request */

  DEBUGASSERT(info->userops != NULL && info->userops->chstat != NULL);
  resp.ret  = info->userops->chstat(info->volinfo, req->relpath,
                                    &req->buf, req->flags);

  /* Send the response */

  resp.resp = USERFS_RESP_CHSTAT;
  nsent     = sendto(info->sockfd, &resp,
                     sizeof(struct userfs_chstat_response_s),
                     0, (FAR struct sockaddr *)&info->client,
                     sizeof(struct sockaddr_in));
  return nsent < 0 ? nsent : OK;
}

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: userfs_run
 *
 * Description:
 *   Start the UserFS server on the current thread.  This function will mount
 *   the UserFS file system and will not return until that file system has
 *   been unmounted.
 *
 *   userfs_run() implements the UserFS server. It performs there operations:
 *
 *   1. It configures and creates the UserFS file system and
 *   2. Mounts the user file system at the provide mount point path.
 *   2. Receives file system requests on the LocalHost socket with
 *      server port 0x83nn where nn is the same as above,
 *   3. Received file system requests are marshaled and dispatch to the
 *      user file system via callbacks to the operations provided by
 *      "userops", and
 *   3. Returns file system responses generated by the callbacks to the
 *      LocalHost client socket.
 *
 *   NOTE:  This is a user function that is implemented as part of the
 *   NuttX C library and is intended to be called by application logic.
 *
 * Input Parameters:
 *   mountpt  - Mountpoint path
 *   userops  - The caller operations that implement the file system
 *              interface.
 *   volinfo  - Private volume data that will be provided in all struct
 *              userfs_operations_s methods.
 *   mxwrite  - The max size of a write data
 *
 *  Returned Value:
 *    This function does not return unless the file system is unmounted (OK)
 *    or unless an error is encountered.  In the event of an error, the
 *    returned value is a negated errno value indicating the nature of the
 *    error.
 *
 ****************************************************************************/

int userfs_run(FAR const char *mountpt,
               FAR const struct userfs_operations_s *userops,
               FAR void *volinfo, size_t mxwrite)
{
  FAR struct userfs_info_s *info;
  FAR struct userfs_config_s config;
  struct sockaddr_in server;
  unsigned int iolen;
  socklen_t addrlen;
  ssize_t nread;
  int ret;

  DEBUGASSERT(mountpt != NULL && userops != NULL && mxwrite <= UINT16_MAX);
  DEBUGASSERT(mxwrite > 0 && mxwrite <= (UINT16_MAX - USERFS_REQ_MAXSIZE));

  /* Allocate a state structure with an I/O buffer to receive UserFS
   * requests
   */

  iolen = USERFS_REQ_MAXSIZE + mxwrite;
  info  = lib_zalloc(SIZEOF_USERFS_INFO_S(iolen));
  if (info == NULL)
    {
      ferr("ERROR: Failed to allocate state structure\n");
      return -ENOMEM;
    }

  /* Initialize the state structure */

  info->userops   = userops;
  info->volinfo   = volinfo;
  info->iolen     = iolen;
  info->mxwrite   = mxwrite;

  /* Create the UserFS configuration that will be provided as optional
   * data when the UserFS is mounted.
   */

  config.mxwrite  = mxwrite;
  config.portno   = userfs_server_portno();

  /* Mounts the user file system at the provided mount point path. */

  ret = mount(NULL, mountpt, "userfs", 0, (FAR const void *)&config);
  if (ret < 0)
    {
      ret = -get_errno();
      ferr("ERROR: mount() failed: %d\n", ret);
      goto errout_with_info;
    }

  /* Create a new LocalHost UDP server socket */

  info->sockfd = socket(PF_INET, SOCK_DGRAM, 0);
  if (info->sockfd < 0)
    {
      ret = -get_errno();
      ferr("ERROR: socket() failed: %d\n", ret);
      goto errout_with_info;
    }

  /* Bind the socket to a server port number */

  server.sin_family      = AF_INET;
  server.sin_port        = HTONS(config.portno);
  server.sin_addr.s_addr = HTONL(INADDR_LOOPBACK);

  ret = bind(info->sockfd, (struct sockaddr *)&server,
             sizeof(struct sockaddr_in));
  if (ret < 0)
    {
      ret = -get_errno();
      ferr("ERROR: bind() failed: %d\n", ret);
      goto errout_with_sockfd;
    }

  /* Receive file system requests on the POSIX message queue as long
   * as the mount persists.
   */

  do
    {
      /* Receive the next file system request */

      finfo("Receiving up %u bytes\n", info->iolen);
      addrlen = sizeof(struct sockaddr_in);
      nread   = recvfrom(info->sockfd, info->iobuffer, info->iolen, 0,
                         (FAR struct sockaddr *)&info->client,
                         &addrlen);
      if (nread < 0)
        {
          ret = -get_errno();
          ferr("ERROR: recvfrom failed: %d\n", ret);
          goto errout_with_sockfd;
        }

      DEBUGASSERT(addrlen == sizeof(struct sockaddr_in));

      /* Process the request according to its request ID */

      DEBUGASSERT(nread >= sizeof(uint8_t));
      switch (*info->iobuffer)
        {
          case USERFS_REQ_OPEN:
            ret = userfs_open_dispatch(info,
                   (FAR struct userfs_open_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_CLOSE:
            ret = userfs_close_dispatch(info,
                   (FAR struct userfs_close_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_READ:
            ret = userfs_read_dispatch(info,
                   (FAR struct userfs_read_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_WRITE:
            ret = userfs_write_dispatch(info,
                   (FAR struct userfs_write_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_SEEK:
            ret = userfs_seek_dispatch(info,
                   (FAR struct userfs_seek_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_IOCTL:
            ret = userfs_ioctl_dispatch(info,
                   (FAR struct userfs_ioctl_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_SYNC:
            ret = userfs_sync_dispatch(info,
                   (FAR struct userfs_sync_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_DUP:
            ret = userfs_dup_dispatch(info,
                   (FAR struct userfs_dup_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_FSTAT:
            ret = userfs_fstat_dispatch(info,
                   (FAR struct userfs_fstat_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_TRUNCATE:
            ret = userfs_truncate_dispatch(info,
                   (FAR struct userfs_truncate_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_OPENDIR:
            ret = userfs_opendir_dispatch(info,
                   (FAR struct userfs_opendir_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_CLOSEDIR:
            ret = userfs_closedir_dispatch(info,
                   (FAR struct userfs_closedir_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_READDIR:
            ret = userfs_readdir_dispatch(info,
                   (FAR struct userfs_readdir_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_REWINDDIR:
            ret = userfs_rewinddir_dispatch(info,
                   (FAR struct userfs_rewinddir_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_STATFS:
            ret = userfs_statfs_dispatch(info,
                   (FAR struct userfs_statfs_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_UNLINK:
            ret = userfs_unlink_dispatch(info,
                   (FAR struct userfs_unlink_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_MKDIR:
            ret = userfs_mkdir_dispatch(info,
                   (FAR struct userfs_mkdir_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_RMDIR:
            ret = userfs_rmdir_dispatch(info,
                   (FAR struct userfs_rmdir_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_RENAME:
            ret = userfs_rename_dispatch(info,
                   (FAR struct userfs_rename_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_STAT:
            ret = userfs_stat_dispatch(info,
                   (FAR struct userfs_stat_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_DESTROY:
            ret = userfs_destroy_dispatch(info,
                   (FAR struct userfs_destroy_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_FCHSTAT:
            ret = userfs_fchstat_dispatch(info,
                   (FAR struct userfs_fchstat_request_s *)info->iobuffer,
                   nread);
            break;

          case USERFS_REQ_CHSTAT:
            ret = userfs_chstat_dispatch(info,
                   (FAR struct userfs_chstat_request_s *)info->iobuffer,
                   nread);
            break;

          default:
            ferr("ERROR: Unrecognized request received: %u\n",
                 *info->iobuffer);
            ret = -EINVAL;
            break;
        }
    }
  while (ret == OK);

  /* Close the LocalHost socket */

errout_with_sockfd:
  close(info->sockfd);

  /* Free the IO Buffer */

errout_with_info:
  lib_free(info);
  return ret;
}