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