phone-side
/
nuttx-bb
9
0
Fork 0
Code Releases Activity

Renamed nuttapp to namedapp; add binfs to nammedapp/ 

git-svn-id: https://nuttx.svn.sourceforge.net/svnroot/nuttx/trunk@3429 7fd9a85b-ad96-42d3-883c-3090e2eb8679
This commit is contained in:
patacongo 2011-03-28 13:01:57 +00:00
parent 6d31237f5e
commit 6379a40ac9
11 changed files with 834 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
apps/ChangeLog.txt
View File

@ -20,3 +20,7 @@
* Creation of auto-generated header files now occurs during the context
build phase.
* Added sdcard insert and eject, nsh command '?' and some code remarks
* Renamed nuttapp to namedapp
* namedapp/binfs.c -- Create a tiny filesystem that can be used
to show the internal named apps under /bin.

4
apps/Make.defs
View File

@ -36,6 +36,6 @@
define REGISTER
@echo "Register: $1"
@echo "{ .name = \"$1\", .priority = $2, .stacksize = $3, .main = $4 }," >> "$(APPDIR)/nuttapp/exec_nuttapp_list.h"
@echo "EXTERN int $4(int argc, char *argv[]);" >> "$(APPDIR)/nuttapp/exec_nuttapp_proto.h"
@echo "{ .name = \"$1\", .priority = $2, .stacksize = $3, .main = $4 }," >> "$(APPDIR)/namedapp/namedapp_list.h"
@echo "EXTERN int $4(int argc, char *argv[]);" >> "$(APPDIR)/namedapp/namedapp_proto.h"
endef

10
apps/Makefile
View File

@ -41,16 +41,16 @@ APPDIR = ${shell pwd}
# Application Directories
# SUBDIRS is the list of all directories containing Makefiles. It is used
# only for cleaning. nuttapp must always be the first in the list.
# only for cleaning. namedapp must always be the first in the list.
SUBDIRS = nuttapp nshlib netutils examples vsn
SUBDIRS = namedapp nshlib netutils examples vsn
# We use a non-existing .built_always to guarantee that Makefile always walks
# into the sub-directories and asks for build. NOTE that nuttapp is always
# into the sub-directories and asks for build. NOTE that namedapp is always
# in the list of applications to be built
BUILTIN_APPS_BUILT = nuttapp/.built_always
BUILTIN_APPS_DIR = nuttapp
BUILTIN_APPS_BUILT = namedapp/.built_always
BUILTIN_APPS_DIR = namedapp
# CONFIGURED_APPS is the list of all configured built-in directories/built action
# It is created by the configured appconfig file (a copy of which appears in this

6
apps/README.txt
View File

@ -6,8 +6,8 @@ This folder provides various applications found in sub-directories.
Application entry points with their requirements are gathered together in
in two files:
- exec_nuttapp_proto.h Entry points, prototype function
- exec_nuttapp_list.h Application specific information and requirements
- namedapp/namedapp_proto.h Entry points, prototype function
- namedapp/namedapp_list.h Application specific information and requirements
The build occurs in several phases as different build targets are executed:
(1) contex, (2) depend, and (3) default (all). Application information is
@ -15,7 +15,7 @@ collected during the make context build phase.
To execute an application function:
exec_nuttapp() is defined in the nuttx/include/apps/apps.h
exec_namedapp() is defined in the nuttx/include/apps/apps.h
NuttShell provides transparent method of invoking the command, when the
following option is enabled:

14
apps/nuttapp/Makefile → apps/namedapp/Makefile
View File

@ -42,7 +42,11 @@ include $(APPDIR)/Make.defs
# Source and object files
ASRCS =
CSRCS = exec_nuttapp.c
CSRCS = namedapp.c exec_namedapp.c
ifeq ($(CONFIG_APPS_BINDIR),y)
CSRCS += binfs.c
endif
AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT))
@ -75,8 +79,8 @@ $(BIN): $(OBJS)
.built: $(BIN)
.context:
@echo "/* List of application requirements, generated during make context. */" > exec_nuttapp_list.h
@echo "/* List of application entry points, generated during make context. */" > exec_nuttapp_proto.h
@echo "/* List of application requirements, generated during make context. */" > namedapp_list.h
@echo "/* List of application entry points, generated during make context. */" > namedapp_proto.h
@touch $@
context: .context
@ -93,8 +97,8 @@ clean:
distclean: clean
@rm -f .context Make.dep .depend
@rm -f exec_nuttapp_list.h
@rm -f exec_nuttapp_proto.h
@rm -f namedapp_list.h
@rm -f namedapp_proto.h
-include Make.dep

601
apps/namedapp/binfs.c Normal file
View File

@ -0,0 +1,601 @@
/****************************************************************************
* apps/namedapps/binfs.c
*
* Copyright (C) 2011 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* References: Linux/Documentation/filesystems/romfs.txt
*
* 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/statfs.h>
#include <sys/stat.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/fs.h>
#include <nuttx/dirent.h>
#include "namedapp.h"
#if !defined(CONFIG_DISABLE_MOUNTPOINT) && defined(CONFIG_APPS_BINDIR)
/****************************************************************************
* Private Types
****************************************************************************/
/* This structure represents the overall mountpoint state. An instance of this
* structure is retained as inode private data on each mountpoint that is
* mounted with a fat32 filesystem.
*/
struct binfs_state_s
{
sem_t bm_sem; /* Used to assume thread-safe access */
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static void binfs_semtake(struct binfs_state_s *bm);
static inline void binfs_semgive(struct binfs_state_s *bm);
static int binfs_open(FAR struct file *filep, const char *relpath,
int oflags, mode_t mode);
static int binfs_close(FAR struct file *filep);
static ssize_t binfs_read(FAR struct file *filep, char *buffer, size_t buflen);
static int binfs_ioctl(FAR struct file *filep, int cmd, unsigned long arg);
static int binfs_opendir(struct inode *mountpt, const char *relpath,
struct fs_dirent_s *dir);
static int binfs_readdir(struct inode *mountpt, struct fs_dirent_s *dir);
static int binfs_rewinddir(struct inode *mountpt, struct fs_dirent_s *dir);
static int binfs_bind(FAR struct inode *blkdriver, const void *data,
void **handle);
static int binfs_unbind(void *handle, FAR struct inode **blkdriver);
static int binfs_statfs(struct inode *mountpt, struct statfs *buf);
static int binfs_stat(struct inode *mountpt, const char *relpath, struct stat *buf);
/****************************************************************************
* Private Variables
****************************************************************************/
/****************************************************************************
* Public Variables
****************************************************************************/
/* See fs_mount.c -- this structure is explicitly externed there.
* We use the old-fashioned kind of initializers so that this will compile
* with any compiler.
*/
const struct mountpt_operations binfs_operations =
{
binfs_open, /* open */
binfs_close, /* close */
binfs_read, /* read */
NULL, /* write */
NULL, /* seek */
binfs_ioctl, /* ioctl */
NULL, /* sync */
binfs_opendir, /* opendir */
NULL, /* closedir */
binfs_readdir, /* readdir */
binfs_rewinddir, /* rewinddir */
binfs_bind, /* bind */
binfs_unbind, /* unbind */
binfs_statfs, /* statfs */
NULL, /* unlink */
NULL, /* mkdir */
NULL, /* rmdir */
NULL, /* rename */
binfs_stat /* stat */
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: binfs_semtake
****************************************************************************/
static void binfs_semtake(struct binfs_state_s *bm)
{
/* Take the semaphore (perhaps waiting) */
while (sem_wait(&bm->bm_sem) != 0)
{
/* The only case that an error should occur here is if
* the wait was awakened by a signal.
*/
ASSERT(*get_errno_ptr() == EINTR);
}
}
/****************************************************************************
* Name: binfs_semgive
****************************************************************************/
static inline void binfs_semgive(struct binfs_state_s *bm)
{
sem_post(&bm->bm_sem);
}
/****************************************************************************
* Name: binfs_open
****************************************************************************/
static int binfs_open(FAR struct file *filep, const char *relpath,
int oflags, mode_t mode)
{
struct binfs_state_s *bm;
int ret = -ENOSYS;
fvdbg("Open '%s'\n", relpath);
/* Sanity checks */
DEBUGASSERT(filep->f_priv == NULL && filep->f_inode != NULL);
/* mountpoint private data from the inode reference from the file
* structure
*/
bm = (struct binfs_state_s*)filep->f_inode->i_private;
DEBUGASSERT(bm != NULL);
/* BINFS is read-only. Any attempt to open with any kind of write
* access is not permitted.
*/
if ((oflags & O_WRONLY) != 0 || (oflags & O_RDONLY) == 0)
{
fdbg("Only O_RDONLY supported\n");
ret = -EACCES;
}
/* Save open-specific state in filep->f_priv */
/* Opening of elements within the pseudo-file system is not yet supported */
return ret;
}
/****************************************************************************
* Name: binfs_close
****************************************************************************/
static int binfs_close(FAR struct file *filep)
{
struct binfs_state_s *bm;
int ret = -ENOSYS;
fvdbg("Closing\n");
/* Sanity checks */
DEBUGASSERT(filep->f_priv != NULL && filep->f_inode != NULL);
/* Recover the open file state from the struct file instance */
/* bf = filep->f_priv; */
/* Recover the file system state from the inode */
bm = filep->f_inode->i_private;
DEBUGASSERT(bm != NULL);
/* Free the open file state */
/* free(bf); */
filep->f_priv = NULL;
/* Since open() is not yet supported, neither is close(). */
return ret;
}
/****************************************************************************
* Name: binfs_read
****************************************************************************/
static ssize_t binfs_read(FAR struct file *filep, char *buffer, size_t buflen)
{
struct binfs_state_s *bm;
fvdbg("Read %d bytes from offset %d\n", buflen, filep->f_pos);
/* Sanity checks */
DEBUGASSERT(filep->f_priv != NULL && filep->f_inode != NULL);
/* Recover the open file state data from the struct file instance */
/* bf = filep->f_priv; */
/* Recover the file system state from the inode */
bm = filep->f_inode->i_private;
DEBUGASSERT(bm != NULL);
/* Since open is not yet supported, neither is reading */
return -ENOSYS;
}
/****************************************************************************
* Name: binfs_ioctl
****************************************************************************/
static int binfs_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
struct binfs_state_s *bm;
fvdbg("cmd: %d arg: %08lx\n", cmd, arg);
/* Sanity checks */
DEBUGASSERT(filep->f_priv != NULL && filep->f_inode != NULL);
/* Recover the open file state from the struct file instance */
/* bf = filep->f_priv; */
/* Recover the file system state from the inode */
bm = filep->f_inode->i_private;
DEBUGASSERT(bm != NULL);
/* No ioctl commands yet supported */
return -ENOTTY;
}
/****************************************************************************
* Name: binfs_opendir
*
* Description:
* Open a directory for read access
*
****************************************************************************/
static int binfs_opendir(struct inode *mountpt, const char *relpath,
struct fs_dirent_s *dir)
{
struct binfs_state_s *bm;
int ret;
fvdbg("relpath: '%s'\n", relpath);
/* Sanity checks */
DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL);
/* Recover the file system state from the inode instance */
bm = mountpt->i_private;
binfs_semtake(bm);
/* The requested directory must be the volume-relative "root" directory */
if (relpath && relpath[0] != '\0')
{
ret = -ENOENT;
goto errout_with_semaphore;
}
/* Set the index to the first entry */
dir->u.binfs.fb_index = 0;
ret = OK;
errout_with_semaphore:
binfs_semgive(bm);
return ret;
}
/****************************************************************************
* Name: binfs_readdir
*
* Description: Read the next directory entry
*
****************************************************************************/
static int binfs_readdir(struct inode *mountpt, struct fs_dirent_s *dir)
{
struct binfs_state_s *bm;
unsigned int index;
int ret;
fvdbg("Entry\n");
/* Sanity checks */
DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL);
/* Recover the file system state from the inode instance */
bm = mountpt->i_private;
binfs_semtake(bm);
/* Have we reached the end of the directory */
index = dir->u.binfs.fb_index;
if (namedapps[index].name == NULL)
{
/* We signal the end of the directory by returning the
* special error -ENOENT
*/
fdbg("End of directory\n");
ret = -ENOENT;
}
else
{
/* Save the filename and file type */
dir->fd_dir.d_type = DTYPE_FILE;
strncpy(dir->fd_dir.d_name, namedapps[index].name, NAME_MAX+1);
/* The application list is terminated by an entry with a NULL name.
* Therefore, there is at least one more entry in the list.
*/
index++;
/* Set up the next directory entry offset. NOTE that we could use the
* standard fr_curroffset instead of our own private fr_curroffset.
*/
dir->u.binfs.fb_index = index;
dir->u.romfs.fr_curroffset = index;
ret = OK;
}
binfs_semgive(bm);
return ret;
}
/****************************************************************************
* Name: binfs_rewindir
*
* Description: Reset directory read to the first entry
*
****************************************************************************/
static int binfs_rewinddir(struct inode *mountpt, struct fs_dirent_s *dir)
{
struct binfs_state_s *bm;
fvdbg("Entry\n");
/* Sanity checks */
DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL);
/* Recover the file system state from the inode instance */
bm = mountpt->i_private;
binfs_semtake(bm);
dir->u.binfs.fb_index = 0;
dir->u.romfs.fr_curroffset = 0;
binfs_semgive(bm);
return OK;
}
/****************************************************************************
* Name: binfs_bind
*
* Description: This implements a portion of the mount operation. This
* function allocates and initializes the mountpoint private data and
* binds the blockdriver inode to the filesystem private data. The final
* binding of the private data (containing the blockdriver) to the
* mountpoint is performed by mount().
*
****************************************************************************/
static int binfs_bind(FAR struct inode *blkdriver, const void *data,
void **handle)
{
struct binfs_state_s *bm;
fvdbg("Entry\n");
/* Create an instance of the mountpt state structure */
bm = (struct binfs_state_s *)zalloc(sizeof(struct binfs_state_s));
if (!bm)
{
fdbg("Failed to allocate mountpoint structure\n");
return -ENOMEM;
}
/* Initialize the allocated mountpt state structure. The filesystem is
* responsible for one reference ont the blkdriver inode and does not
* have to addref() here (but does have to release in ubind().
*/
sem_init(&bm->bm_sem, 0, 1); /* Initialize the semaphore that controls access */
/* Mounted! */
*handle = (void*)bm;
return OK;
}
/****************************************************************************
* Name: binfs_unbind
*
* Description: This implements the filesystem portion of the umount
* operation.
*
****************************************************************************/
static int binfs_unbind(void *handle, FAR struct inode **blkdriver)
{
struct binfs_state_s *bm = (struct binfs_state_s*)handle;
fvdbg("Entry\n");
#ifdef CONFIG_DEBUG
if (!bm)
{
return -EINVAL;
}
#endif
/* Check if there are sill any files opened on the filesystem. */
/* Release the mountpoint private data */
sem_destroy(&bm->bm_sem);
return OK;
}
/****************************************************************************
* Name: binfs_statfs
*
* Description: Return filesystem statistics
*
****************************************************************************/
static int binfs_statfs(struct inode *mountpt, struct statfs *buf)
{
struct binfs_state_s *bm;
fvdbg("Entry\n");
/* Sanity checks */
DEBUGASSERT(mountpt && mountpt->i_private);
/* Get the mountpoint private data from the inode structure */
bm = mountpt->i_private;
binfs_semtake(bm);
/* Fill in the statfs info */
memset(buf, 0, sizeof(struct statfs));
buf->f_type = BINFS_MAGIC;
buf->f_bsize = 0;
buf->f_blocks = 0;
buf->f_bfree = 0;
buf->f_bavail = 0;
buf->f_namelen = NAME_MAX;
binfs_semgive(bm);
return OK;
}
/****************************************************************************
* Name: binfs_stat
*
* Description: Return information about a file or directory
*
****************************************************************************/
static int binfs_stat(struct inode *mountpt, const char *relpath, struct stat *buf)
{
struct binfs_state_s *bm;
int ret;
fvdbg("Entry\n");
/* Sanity checks */
DEBUGASSERT(mountpt && mountpt->i_private);
/* Get the mountpoint private data from the inode structure */
bm = mountpt->i_private;
binfs_semtake(bm);
/* The requested directory must be the volume-relative "root" directory */
if (relpath && relpath[0] != '\0')
{
/* It's a read-only directory name */
buf->st_mode = S_IFDIR|S_IROTH|S_IRGRP|S_IRUSR|S_IXOTH|S_IXGRP|S_IXUSR;
}
else
{
/* Check if there is a file with this name. */
if (namedapp_isavail(relpath) < 0)
{
ret = -ENOENT;
goto errout_with_semaphore;
}
/* It's a read-only file name */
buf->st_mode = S_IFREG|S_IROTH|S_IRGRP|S_IRUSR|S_IXOTH|S_IXGRP|S_IXUSR;
}
/* File/directory size, access block size */
buf->st_size = 0;
buf->st_blksize = 0;
buf->st_blocks = 0;
ret = OK;
errout_with_semaphore:
binfs_semgive(bm);
return ret;
}
/****************************************************************************
* Public Functions
****************************************************************************/
#endif /* !CONFIG_DISABLE_MOUNTPOINT && CONFIG_APPS_BINDIR */

90
apps/nuttapp/exec_nuttapp.c → apps/namedapp/exec_namedapp.c
View File

@ -1,5 +1,5 @@
/****************************************************************************
* drivers/sbin/exec_nuttapp.c
* apps/namedaps/exec_namedapp.c
*
* Copyright (C) 2011 Uros Platise. All rights reserved.
* Author: Uros Platise <uros.platise@isotel.eu>
@ -44,105 +44,79 @@
#include <string.h>
#include <errno.h>
#include "namedapp.h"
/****************************************************************************
* Private Types
****************************************************************************/
/* Load builtin function prototypes */
#undef EXTERN
#if defined(__cplusplus)
#define EXTERN extern "C"
extern "C" {
#else
#define EXTERN extern
#endif
#include "exec_nuttapp_proto.h"
static const struct nuttapp_s nuttapps[] = {
# include "exec_nuttapp_list.h"
{.name=NULL}
};
#undef EXTERN
#if defined(__cplusplus)
}
#endif
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
const char * nuttapp_getname(int index)
const char *namedapp_getname(int index)
{
if ( index < 0 || index >= (sizeof(nuttapps)/sizeof(struct nuttapp_s)) )
return NULL;
if (index < 0 || index >= number_namedapps())
{
return NULL;
}
return nuttapps[index].name;
return namedapps[index].name;
}
int nuttapp_isavail(FAR const char *appname)
int namedapp_isavail(FAR const char *appname)
{
int i;
for (i=0; nuttapps[i].name; i++)
{
if ( !strcmp(nuttapps[i].name, appname) )
return i;
}
for (i = 0; namedapps[i].name; i++)
{
if (!strcmp(namedapps[i].name, appname))
{
return i;
}
}
errno = ENOENT;
return -1;
}
int exec_nuttapp(FAR const char *appname, FAR const char *argv[])
int exec_namedapp(FAR const char *appname, FAR const char *argv[])
{
int i;
if ( (i = nuttapp_isavail(appname)) >= 0 )
{
if ((i = namedapp_isavail(appname)) >= 0)
{
#ifndef CONFIG_CUSTOM_STACK
i = task_create(nuttapps[i].name, nuttapps[i].priority,
nuttapps[i].stacksize, nuttapps[i].main,
(argv) ? &argv[1] : (const char **)NULL);
i = task_create(namedapps[i].name, namedapps[i].priority,
namedapps[i].stacksize, namedapps[i].main,
(argv) ? &argv[1] : (const char **)NULL);
#else
i = task_create(nuttapps[i].name, nuttapps[i].priority, nuttapps[i].main,
(argv) ? &argv[1] : (const char **)NULL);
i = task_create(namedapps[i].name, namedapps[i].priority, namedapps[i].main,
(argv) ? &argv[1] : (const char **)NULL);
#endif
#if CONFIG_RR_INTERVAL > 0
if (i > 0)
{
struct sched_param param;
if (i > 0)
{
struct sched_param param;
sched_getparam(0, &param);
sched_setscheduler(i, SCHED_RR, &param);
}
sched_getparam(0, &param);
sched_setscheduler(i, SCHED_RR, &param);
}
#endif
return i;
}
}
return i;
}

96
apps/namedapp/namedapp.c Normal file
View File

@ -0,0 +1,96 @@
/****************************************************************************
* apps/namedaps/namedapp.c
*
* Copyright (C) 2011 Uros Platise. All rights reserved.
* Copyright (C) 2011 Gregory Nutt. All rights reserved.
* Authors: Uros Platise <uros.platise@isotel.eu>
* Gregory Nutt <spudmonkey@racsa.co.cr>
*
* 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 <apps/apps.h>
/****************************************************************************
* Private Types
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
#undef EXTERN
#if defined(__cplusplus)
#define EXTERN extern "C"
extern "C" {
#else
#define EXTERN extern
#endif
#include "namedapp_proto.h"
const struct namedapp_s namedapps[] =
{
# include "namedapp_list.h"
{.name = NULL}
};
#undef EXTERN
#if defined(__cplusplus)
}
#endif
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
int number_namedapps(void)
{
return sizeof(namedapps)/sizeof(struct namedapp_s) - 1;
}

78
apps/namedapp/namedapp.h Normal file
View File

@ -0,0 +1,78 @@
/****************************************************************************
* apps/namedaps/namedapp.h
*
* Copyright (C) 2011 Uros Platise. All rights reserved.
* Copyright (C) 2011 Gregory Nutt. All rights reserved.
* Authors: Uros Platise <uros.platise@isotel.eu>
* Gregory Nutt <spudmonkey@racsa.co.cr>
*
* 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.
*
****************************************************************************/
#ifndef __APPS_NAMEDAPP_NAMEDAPP_H
#define __APPS_NAMEDAPP_NAMEDAPP_H
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <apps/apps.h>
/****************************************************************************
* Public Types
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
#undef EXTERN
#if defined(__cplusplus)
#define EXTERN extern "C"
extern "C" {
#else
#define EXTERN extern
#endif
EXTERN const struct namedapp_s namedapps[];
/****************************************************************************
* Public Functions
****************************************************************************/
EXTERN int number_namedapps(void);
#undef EXTERN
#if defined(__cplusplus)
}
#endif
#endif /* __APPS_NAMEDAPP_NAMEDAPP_H */

4
apps/nshlib/nsh_apps.c
View File

@ -93,7 +93,7 @@ int nsh_execapp(FAR struct nsh_vtbl_s *vtbl, FAR const char *cmd,
/* Try to find command within pre-built application list. */
ret = exec_nuttapp(cmd, argv);
ret = exec_namedapp(cmd, argv);
if (ret < 0)
{
int err = -errno;
@ -102,7 +102,7 @@ int nsh_execapp(FAR struct nsh_vtbl_s *vtbl, FAR const char *cmd,
/* On failure, list the set of available built-in commands */
nsh_output(vtbl, "Builtin Apps: ");
for (i = 0; (name = nuttapp_getname(i)) != NULL; i++)
for (i = 0; (name = namedapp_getname(i)) != NULL; i++)
{
nsh_output(vtbl, "%s ", name);
}

4
apps/nshlib/nsh_parse.c
View File

@ -1152,13 +1152,13 @@ int nsh_parse(FAR struct nsh_vtbl_s *vtbl, char *cmdline)
}
/* Handle the case where the command is executed in background.
* However is app is to be started as nuttapp new process will
* However is app is to be started as namedapp new process will
* be created anyway, so skip this step. */
#ifndef CONFIG_NSH_DISABLEBG
if (vtbl->np.np_bg
#ifdef CONFIG_NSH_BUILTIN_APPS
&& nuttapp_isavail(argv[0]) < 0
&& namedapp_isavail(argv[0]) < 0
#endif
)
{