/**************************************************************************** * 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 #include #include #include #include #include #include #include #include #include #include #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; }