system/popen: add dpopen/dpclose fd-based interface

Add dpopen()/dpclose() as the descriptor-based counterpart of
popen()/pclose(), analogous to how dprintf() relates to fprintf().
dpopen() returns a raw file descriptor instead of a FILE stream,
avoiding the stdio.h dependency for callers that only need an fd.

Refactor popen() as a thin wrapper: dpopen() + fdopen() + FILE
container.  All pipe creation and process spawning logic now lives
in dpopen.c.

Also remove the hard dependency on NSH_LIBRARY from SYSTEM_POPEN.
When NSH is available, commands are executed through sh -c with full
shell syntax support.  When NSH is not available, commands are split
by whitespace and executed directly via posix_spawnp().

Add CONFIG_SYSTEM_POPEN_MAXARGUMENTS (default 7) to control the
argv array size for the no-shell path.

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

Author: cuiziweizw

system/popen/CMakeLists.txt

@@ -21,5 +21,5 @@
 # ##############################################################################
 
 if(CONFIG_SYSTEM_POPEN)
-  target_sources(apps PRIVATE popen.c)
+  target_sources(apps PRIVATE dpopen.c popen.c)
 endif()

system/popen/Kconfig

@@ -4,14 +4,25 @@
 #
 
 config SYSTEM_POPEN
-	bool "popen()/pclose() Functions"
+	bool "popen()/pclose()/dpopen()/dpclose() Functions"
 	default n
 	select SCHED_WAITPID
 	depends on NSH_LIBRARY && PIPES
 	---help---
-		Enable support for the popen() and pclose() interfaces.
-		This will support execution of NSH commands from C code with
-		pipe communications with the shell.
+		Enable support for the popen(), pclose(), dpopen(), and
+		dpclose() interfaces.
+
+		dpopen()/dpclose() are the descriptor-based counterparts
+		of popen()/pclose(), analogous to how dprintf() relates
+		to fprintf().  They return a raw file descriptor instead
+		of a FILE stream, avoiding the stdio.h dependency.
+
+		popen()/pclose() are thin wrappers around dpopen()/dpclose()
+		that additionally wrap the fd in a FILE stream.
+
+		Commands are executed through the NSH shell (sh -c command),
+		supporting full shell syntax including pipes, redirects,
+		and globbing.
 
 if SYSTEM_POPEN
 

system/popen/Makefile

@@ -22,8 +22,8 @@
 
 include $(APPDIR)/Make.defs
 
-# popen()/pclose functions
+# dpopen()/dpclose() core and popen()/pclose() FILE wrappers
 
-CSRCS = popen.c
+CSRCS = dpopen.c popen.c
 
 include $(APPDIR)/Application.mk

system/popen/dpopen.c

@@ -0,0 +1,321 @@
+/****************************************************************************
+ * apps/system/popen/dpopen.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/wait.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <sched.h>
+#include <spawn.h>
+#include <debug.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#if defined(CONFIG_NET_LOCAL) && defined(CONFIG_NET_LOCAL_STREAM)
+#  include <sys/socket.h>
+#endif
+
+#include "nshlib/nshlib.h"
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: dpopen
+ *
+ * Description:
+ *   Execute a command and return a raw file descriptor connected to the
+ *   child process via a pipe, along with the child PID.
+ *
+ *   This is the descriptor-based counterpart of popen(), analogous to how
+ *   dprintf() relates to fprintf().  It avoids the FILE stream layer,
+ *   making it suitable for callers that only need a raw fd and want to
+ *   avoid the stdio.h dependency.
+ *
+ *   When NSH is available, commands are executed through the shell
+ *   (sh -c command), supporting full shell syntax.
+ *
+ * Input Parameters:
+ *   command - The command string to execute
+ *   oflag   - O_RDONLY to read child stdout, O_WRONLY to write child stdin,
+ *             O_RDWR for bidirectional socket mode
+ *   pid     - Location to return the child process ID
+ *
+ * Returned Value:
+ *   A valid file descriptor on success, or -1 on failure with errno set.
+ *
+ ****************************************************************************/
+
+int dpopen(FAR const char *command, int oflag, FAR pid_t *pid)
+{
+  struct sched_param param;
+  posix_spawnattr_t attr;
+  posix_spawn_file_actions_t file_actions;
+  FAR char *argv[4];
+  int fd[2];
+  int childfd;
+  int parentfd;
+  int errcode;
+
+  if (command == NULL || pid == NULL)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+
+  /* Create a pipe or socketpair.  fd[0] refers to the read end of the
+   * pipe; fd[1] refers to the write end of the pipe.
+   */
+
+  if ((oflag & O_RDWR) == O_RDWR)
+    {
+#if defined(CONFIG_NET_LOCAL) && defined(CONFIG_NET_LOCAL_STREAM)
+      /* Create a socketpair for bidirectional communication */
+
+      if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, fd) < 0)
+        {
+          return -1;
+        }
+
+      childfd  = fd[0];
+      parentfd = fd[1];
+#else
+      errno = ENOTSUP;
+      return -1;
+#endif
+    }
+  else if (pipe2(fd, O_CLOEXEC) < 0)
+    {
+      return -1;
+    }
+  else if ((oflag & O_ACCMODE) == O_RDONLY)
+    {
+      /* Pipe is the output from the child */
+
+      childfd  = fd[1];  /* Child writes to pipe */
+      parentfd = fd[0];  /* Parent reads from pipe */
+    }
+  else if ((oflag & O_ACCMODE) == O_WRONLY)
+    {
+      /* Pipe is the input to the child */
+
+      childfd  = fd[0];  /* Child reads from pipe */
+      parentfd = fd[1];  /* Parent writes to pipe */
+    }
+  else
+    {
+      errcode = EINVAL;
+      goto errout_with_pipe;
+    }
+
+  /* Initialize attributes for task_spawn() (or posix_spawn()). */
+
+  errcode = posix_spawnattr_init(&attr);
+  if (errcode != 0)
+    {
+      goto errout_with_pipe;
+    }
+
+  errcode = posix_spawn_file_actions_init(&file_actions);
+  if (errcode != 0)
+    {
+      goto errout_with_attr;
+    }
+
+  /* Set the correct stack size and priority */
+
+  param.sched_priority = CONFIG_SYSTEM_POPEN_PRIORITY;
+  errcode = posix_spawnattr_setschedparam(&attr, &param);
+  if (errcode != 0)
+    {
+      goto errout_with_actions;
+    }
+
+#ifndef CONFIG_SYSTEM_POPEN_SHPATH
+  errcode = posix_spawnattr_setstacksize(&attr,
+                                         CONFIG_SYSTEM_POPEN_STACKSIZE);
+  if (errcode != 0)
+    {
+      goto errout_with_actions;
+    }
+#endif
+
+  /* If robin robin scheduling is enabled, then set the scheduling policy
+   * of the new task to SCHED_RR before it has a chance to run.
+   */
+
+#if CONFIG_RR_INTERVAL > 0
+  errcode = posix_spawnattr_setschedpolicy(&attr, SCHED_RR);
+  if (errcode != 0)
+    {
+      goto errout_with_actions;
+    }
+
+  errcode = posix_spawnattr_setflags(&attr,
+                                     POSIX_SPAWN_SETSCHEDPARAM |
+                                     POSIX_SPAWN_SETSCHEDULER);
+  if (errcode != 0)
+    {
+      goto errout_with_actions;
+    }
+
+#else
+  errcode = posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETSCHEDPARAM);
+  if (errcode != 0)
+    {
+      goto errout_with_actions;
+    }
+
+#endif
+
+  /* Redirect child's stdin or stdout to the pipe */
+
+  if ((oflag & O_RDWR) == O_RDWR)
+    {
+      errcode = posix_spawn_file_actions_adddup2(&file_actions, childfd,
+                                                 STDIN_FILENO);
+      if (errcode != 0)
+        {
+          goto errout_with_actions;
+        }
+
+      errcode = posix_spawn_file_actions_adddup2(&file_actions, childfd,
+                                                 STDOUT_FILENO);
+      if (errcode != 0)
+        {
+          goto errout_with_actions;
+        }
+    }
+  else
+    {
+      errcode = posix_spawn_file_actions_adddup2(&file_actions, childfd,
+                   (oflag & O_ACCMODE) == O_RDONLY ?
+                   STDOUT_FILENO : STDIN_FILENO);
+      if (errcode != 0)
+        {
+          goto errout_with_actions;
+        }
+    }
+
+  /* Call task_spawn() (or posix_spawn), re-directing stdin or stdout
+   * appropriately.
+   */
+
+  argv[1] = "-c";
+  argv[2] = (FAR char *)command;
+  argv[3] = NULL;
+
+#ifdef CONFIG_SYSTEM_POPEN_SHPATH
+  argv[0] = CONFIG_SYSTEM_POPEN_SHPATH;
+  errcode = posix_spawn(pid, argv[0], &file_actions,
+                        &attr, argv, NULL);
+#else
+  *pid = task_spawn("dpopen", nsh_system, &file_actions,
+                    &attr, argv + 1, NULL);
+  if (*pid < 0)
+    {
+      errcode = -*pid;
+    }
+#endif
+
+  if (errcode != 0)
+    {
+      serr("ERROR: dpopen spawn failed: %d\n", errcode);
+      goto errout_with_pipe;
+    }
+
+  /* Free attributes and file actions */
+
+  posix_spawn_file_actions_destroy(&file_actions);
+  posix_spawnattr_destroy(&attr);
+
+  /* Close the child's end in the parent */
+
+  if (!(oflag & O_CLOEXEC))
+    {
+      ioctl(parentfd, FIONCLEX, 0);
+    }
+
+  close(childfd);
+
+  return parentfd;
+
+errout_with_actions:
+  posix_spawn_file_actions_destroy(&file_actions);
+
+errout_with_attr:
+  posix_spawnattr_destroy(&attr);
+
+errout_with_pipe:
+  close(fd[0]);
+  close(fd[1]);
+  errno = errcode;
+  return -1;
+}
+
+/****************************************************************************
+ * Name: dpclose
+ *
+ * Description:
+ *   Close a file descriptor opened by dpopen() and wait for the child
+ *   process to terminate.
+ *
+ *   This is the descriptor-based counterpart of pclose().
+ *
+ * Input Parameters:
+ *   fd  - The file descriptor returned by dpopen()
+ *   pid - The child process ID returned by dpopen()
+ *
+ * Returned Value:
+ *   The child termination status on success, or -1 on failure with
+ *   errno set.
+ *
+ ****************************************************************************/
+
+int dpclose(int fd, pid_t pid)
+{
+#ifdef CONFIG_SCHED_WAITPID
+  int status;
+  int ret;
+#endif
+
+  if (fd >= 0)
+    {
+      close(fd);
+    }
+
+#ifdef CONFIG_SCHED_WAITPID
+  ret = waitpid(pid, &status, 0);
+  if (ret < 0)
+    {
+      return ERROR;
+    }
+
+  return status;
+#else
+  return 0;
+#endif
+}