36a0c924f7
Signed-off-by: Xiang Xiao <xiaoxiang@xiaomi.com> Signed-off-by: chao an <anchao@xiaomi.com>
335 lines
8.8 KiB
C
335 lines
8.8 KiB
C
/****************************************************************************
|
|
* apps/netutils/telnetd/telnetd_daemon.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/socket.h>
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <signal.h>
|
|
#include <sched.h>
|
|
#include <spawn.h>
|
|
#include <errno.h>
|
|
#include <debug.h>
|
|
|
|
#include <nuttx/net/telnet.h>
|
|
|
|
#include "netutils/telnetd.h"
|
|
#include "netutils/netlib.h"
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: telnetd_daemon
|
|
*
|
|
* Description:
|
|
* This function is the Telnet daemon. It does not return (unless an
|
|
* error occurs).
|
|
*
|
|
* Parameters:
|
|
* Standard task start up arguments.
|
|
*
|
|
* Return:
|
|
* Does not return unless an error occurs.
|
|
*
|
|
****************************************************************************/
|
|
|
|
int telnetd_daemon(FAR const struct telnetd_config_s *config)
|
|
{
|
|
union
|
|
{
|
|
struct sockaddr generic;
|
|
#ifdef CONFIG_NET_IPv4
|
|
struct sockaddr_in ipv4;
|
|
#endif
|
|
#ifdef CONFIG_NET_IPv6
|
|
struct sockaddr_in6 ipv6;
|
|
#endif
|
|
} addr;
|
|
|
|
#ifdef CONFIG_SCHED_HAVE_PARENT
|
|
struct sigaction sa;
|
|
sigset_t blockset;
|
|
#endif
|
|
socklen_t addrlen;
|
|
int listensd;
|
|
int acceptsd;
|
|
#ifdef CONFIG_NET_SOCKOPTS
|
|
int optval;
|
|
#endif
|
|
|
|
#ifdef CONFIG_SCHED_HAVE_PARENT
|
|
/* Call sigaction with the SA_NOCLDWAIT flag so that we do not transform
|
|
* children into "zombies" when they terminate: Child exit status will
|
|
* not be retained.
|
|
*
|
|
* NOTE: If the SA_NOCLDWAIT flag is set when establishing a handler for
|
|
* SIGCHLD, POSIX.1 leaves it unspecified whether a SIGCHLD signal is
|
|
* generated when a child process terminates. On both Linux and NuttX, a
|
|
* SIGCHLD signal will be generated in this case.
|
|
*/
|
|
|
|
sa.sa_handler = SIG_IGN;
|
|
sa.sa_flags = SA_NOCLDWAIT;
|
|
if (sigaction(SIGCHLD, &sa, NULL) < 0)
|
|
{
|
|
nerr("ERROR: sigaction failed: %d\n", errno);
|
|
goto errout;
|
|
}
|
|
|
|
/* Block receipt of the SIGCHLD signal */
|
|
|
|
sigemptyset(&blockset);
|
|
sigaddset(&blockset, SIGCHLD);
|
|
if (sigprocmask(SIG_BLOCK, &blockset, NULL) < 0)
|
|
{
|
|
nerr("ERROR: sigprocmask failed: %d\n", errno);
|
|
goto errout;
|
|
}
|
|
#endif /* CONFIG_SCHED_HAVE_PARENT */
|
|
|
|
/* Create a new TCP socket to use to listen for connections */
|
|
|
|
listensd = socket(config->d_family, SOCK_STREAM | SOCK_CLOEXEC, 0);
|
|
if (listensd < 0)
|
|
{
|
|
nerr("ERROR: socket() failed for family %u: %d\n",
|
|
config->d_family, errno);
|
|
goto errout;
|
|
}
|
|
|
|
#ifdef CONFIG_NET_SOCKOPTS
|
|
/* Set socket to reuse address */
|
|
|
|
optval = 1;
|
|
if (setsockopt(listensd, SOL_SOCKET, SO_REUSEADDR,
|
|
&optval, sizeof(int)) < 0)
|
|
{
|
|
nerr("ERROR: setsockopt SO_REUSEADDR failure: %d\n", errno);
|
|
goto errout_with_socket;
|
|
}
|
|
#endif
|
|
|
|
/* Bind the socket to a local address */
|
|
|
|
#ifdef CONFIG_NET_IPv4
|
|
if (config->d_family == AF_INET)
|
|
{
|
|
addr.ipv4.sin_family = AF_INET;
|
|
addr.ipv4.sin_port = config->d_port;
|
|
addr.ipv4.sin_addr.s_addr = INADDR_ANY;
|
|
addrlen = sizeof(struct sockaddr_in);
|
|
}
|
|
else
|
|
#endif
|
|
#ifdef CONFIG_NET_IPv6
|
|
if (config->d_family == AF_INET6)
|
|
{
|
|
addr.ipv6.sin6_family = AF_INET6;
|
|
addr.ipv6.sin6_port = config->d_port;
|
|
addrlen = sizeof(struct sockaddr_in6);
|
|
|
|
memset(addr.ipv6.sin6_addr.s6_addr, 0,
|
|
sizeof(addr.ipv6.sin6_addr.s6_addr));
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
nerr("ERROR: Unsupported address family: %u", config->d_family);
|
|
goto errout_with_socket;
|
|
}
|
|
|
|
if (bind(listensd, &addr.generic, addrlen) < 0)
|
|
{
|
|
nerr("ERROR: bind failure: %d\n", errno);
|
|
goto errout_with_socket;
|
|
}
|
|
|
|
/* Listen for connections on the bound TCP socket */
|
|
|
|
if (listen(listensd, 5) < 0)
|
|
{
|
|
nerr("ERROR: listen failure %d\n", errno);
|
|
goto errout_with_socket;
|
|
}
|
|
|
|
/* Begin accepting connections */
|
|
|
|
for (; ; )
|
|
{
|
|
struct telnet_session_s session;
|
|
#ifdef CONFIG_NET_SOLINGER
|
|
struct linger ling;
|
|
#endif
|
|
int drvrfd;
|
|
|
|
/* Now go silent. */
|
|
|
|
close(0);
|
|
close(1);
|
|
close(2);
|
|
|
|
ninfo("Accepting connections on port %d\n", ntohs(config->d_port));
|
|
|
|
addrlen = sizeof(addr);
|
|
acceptsd = accept(listensd, &addr.generic, &addrlen);
|
|
if (acceptsd < 0)
|
|
{
|
|
/* Just continue if a signal was received */
|
|
|
|
if (errno == EINTR)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
nerr("ERROR: accept failed: %d\n", errno);
|
|
goto errout_with_socket;
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_NET_SOLINGER
|
|
/* Configure to "linger" until all data is sent when the socket is
|
|
* closed
|
|
*/
|
|
|
|
ling.l_onoff = 1;
|
|
ling.l_linger = 30; /* timeout is seconds */
|
|
if (setsockopt(acceptsd, SOL_SOCKET, SO_LINGER,
|
|
&ling, sizeof(struct linger)) < 0)
|
|
{
|
|
nerr("ERROR: setsockopt failed: %d\n", errno);
|
|
goto errout_with_acceptsd;
|
|
}
|
|
#endif
|
|
|
|
/* Open the Telnet factory */
|
|
|
|
drvrfd = open("/dev/telnet", O_RDONLY);
|
|
if (drvrfd < 0)
|
|
{
|
|
nerr("ERROR: open(/dev/telnet) failed: %d\n", errno);
|
|
goto errout_with_acceptsd;
|
|
}
|
|
|
|
/* Create a character device to "wrap" the accepted socket descriptor */
|
|
|
|
ninfo("Creating the telnet driver\n");
|
|
|
|
session.ts_sd = acceptsd;
|
|
session.ts_devpath[0] = '\0';
|
|
|
|
if (ioctl(drvrfd, SIOCTELNET,
|
|
(unsigned long)((uintptr_t)&session)) < 0)
|
|
{
|
|
nerr("ERROR: open(/dev/telnet) failed: %d\n", errno);
|
|
close(drvrfd);
|
|
goto errout_with_acceptsd;
|
|
}
|
|
|
|
close(drvrfd);
|
|
|
|
/* Open the driver */
|
|
|
|
ninfo("Opening the telnet driver at %s\n", session.ts_devpath);
|
|
drvrfd = open(session.ts_devpath, O_RDWR);
|
|
if (drvrfd < 0)
|
|
{
|
|
nerr("ERROR: Failed to open %s: %d\n", session.ts_devpath, errno);
|
|
goto errout_with_socket;
|
|
}
|
|
|
|
/* Use this driver as stdin, stdout, and stderror */
|
|
|
|
dup2(drvrfd, 0);
|
|
dup2(drvrfd, 1);
|
|
dup2(drvrfd, 2);
|
|
|
|
/* And we can close our original driver fd */
|
|
|
|
if (drvrfd > 2)
|
|
{
|
|
close(drvrfd);
|
|
}
|
|
|
|
/* Create a task to handle the connection. The created task
|
|
* will inherit the new stdin, stdout, and stderr.
|
|
*/
|
|
|
|
ninfo("Starting the telnet session\n");
|
|
|
|
#ifndef CONFIG_BUILD_KERNEL
|
|
if (config->t_entry)
|
|
{
|
|
pid_t pid = task_create("Telnet session",
|
|
config->t_priority, config->t_stacksize,
|
|
config->t_entry, NULL);
|
|
if (pid >= 0)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_LIBC_EXECFUNCS
|
|
if (config->t_path)
|
|
{
|
|
struct sched_param param;
|
|
posix_spawnattr_t attr;
|
|
pid_t pid;
|
|
int ret;
|
|
|
|
sched_getparam(0, ¶m);
|
|
param.sched_priority = config->t_priority;
|
|
|
|
posix_spawnattr_init(&attr);
|
|
posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETSCHEDPARAM);
|
|
posix_spawnattr_setschedparam(&attr, ¶m);
|
|
posix_spawnattr_setstacksize(&attr, config->t_stacksize);
|
|
|
|
ret = posix_spawnp(&pid, config->t_path, NULL,
|
|
&attr, config->t_argv, NULL);
|
|
if (ret > 0)
|
|
{
|
|
nerr("ERROR: Failed start the telnet session: %d\n", ret);
|
|
errno = ret;
|
|
goto errout_with_socket;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
errout_with_acceptsd:
|
|
close(acceptsd);
|
|
|
|
errout_with_socket:
|
|
close(listensd);
|
|
errout:
|
|
return errno;
|
|
}
|