src/shared/libosmocore/src/vty/telnet_interface.c

   1 /* minimalistic telnet/network interface it might turn into a wire interface */
   2 /* (C) 2009 by Holger Hans Peter Freyther <zecke@selfish.org>
   3  * All Rights Reserved
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  */
  20
  21 #include <sys/socket.h>
  22 #include <netinet/in.h>
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27
  28 #include <osmocom/core/msgb.h>
  29 #include <osmocom/core/talloc.h>
  30 #include <osmocom/core/logging.h>
  31
  32 #include <osmocom/vty/telnet_interface.h>
  33 #include <osmocom/vty/buffer.h>
  34 #include <osmocom/vty/command.h>
  35
  36 /* per connection data */
  37 LLIST_HEAD(active_connections);
  38
  39 static void *tall_telnet_ctx;
  40
  41 /* per network data */
  42 static int telnet_new_connection(struct bsc_fd *fd, unsigned int what);
  43
  44 static struct bsc_fd server_socket = {
  45         .when       = BSC_FD_READ,
  46         .cb         = telnet_new_connection,
  47         .priv_nr    = 0,
  48 };
  49
  50 int telnet_init(void *tall_ctx, void *priv, int port)
  51 {
  52         struct sockaddr_in sock_addr;
  53         int fd, rc, on = 1;
  54
  55         tall_telnet_ctx = talloc_named_const(tall_ctx, 1,
  56                                              "telnet_connection");
  57
  58         fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
  59
  60         if (fd < 0) {
  61                 LOGP(0, LOGL_ERROR, "Telnet interface socket creation failed\n");
  62                 return fd;
  63         }
  64
  65         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
  66
  67         memset(&sock_addr, 0, sizeof(sock_addr));
  68         sock_addr.sin_family = AF_INET;
  69         sock_addr.sin_port = htons(port);
  70         sock_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
  71
  72         rc = bind(fd, (struct sockaddr*)&sock_addr, sizeof(sock_addr));
  73         if (rc < 0) {
  74                 LOGP(0, LOGL_ERROR, "Telnet interface failed to bind\n");
  75                 close(fd);
  76                 return rc;
  77         }
  78
  79         rc = listen(fd, 0);
  80         if (rc < 0) {
  81                 LOGP(0, LOGL_ERROR, "Telnet interface failed to listen\n");
  82                 close(fd);
  83                 return rc;
  84         }
  85
  86         server_socket.data = priv;
  87         server_socket.fd = fd;
  88         bsc_register_fd(&server_socket);
  89
  90         return 0;
  91 }
  92
  93 extern struct host host;
  94
  95 static void print_welcome(int fd)
  96 {
  97         int ret;
  98         static char *msg =
  99                 "Welcome to the OpenBSC Control interface\r\n";
 100
 101         ret = write(fd, msg, strlen(msg));
 102
 103         if (host.app_info->copyright)
 104                 ret = write(fd, host.app_info->copyright, strlen(host.app_info->copyright));
 105 }
 106
 107 int telnet_close_client(struct bsc_fd *fd)
 108 {
 109         struct telnet_connection *conn = (struct telnet_connection*)fd->data;
 110
 111         close(fd->fd);
 112         bsc_unregister_fd(fd);
 113
 114         if (conn->dbg) {
 115                 log_del_target(conn->dbg);
 116                 talloc_free(conn->dbg);
 117         }
 118
 119         llist_del(&conn->entry);
 120         talloc_free(conn);
 121         return 0;
 122 }
 123
 124 static int client_data(struct bsc_fd *fd, unsigned int what)
 125 {
 126         struct telnet_connection *conn = fd->data;
 127         int rc = 0;
 128
 129         if (what & BSC_FD_READ) {
 130                 conn->fd.when &= ~BSC_FD_READ;
 131                 rc = vty_read(conn->vty);
 132         }
 133
 134         /* vty might have been closed from vithin vty_read() */
 135         if (!conn->vty)
 136                 return rc;
 137
 138         if (what & BSC_FD_WRITE) {
 139                 rc = buffer_flush_all(conn->vty->obuf, fd->fd);
 140                 if (rc == BUFFER_EMPTY)
 141                         conn->fd.when &= ~BSC_FD_WRITE;
 142         }
 143
 144         return rc;
 145 }
 146
 147 static int telnet_new_connection(struct bsc_fd *fd, unsigned int what)
 148 {
 149         struct telnet_connection *connection;
 150         struct sockaddr_in sockaddr;
 151         socklen_t len = sizeof(sockaddr);
 152         int new_connection = accept(fd->fd, (struct sockaddr*)&sockaddr, &len);
 153
 154         if (new_connection < 0) {
 155                 LOGP(0, LOGL_ERROR, "telnet accept failed\n");
 156                 return new_connection;
 157         }
 158
 159         connection = talloc_zero(tall_telnet_ctx, struct telnet_connection);
 160         connection->priv = fd->data;
 161         connection->fd.data = connection;
 162         connection->fd.fd = new_connection;
 163         connection->fd.when = BSC_FD_READ;
 164         connection->fd.cb = client_data;
 165         bsc_register_fd(&connection->fd);
 166         llist_add_tail(&connection->entry, &active_connections);
 167
 168         print_welcome(new_connection);
 169
 170         connection->vty = vty_create(new_connection, connection);
 171         if (!connection->vty) {
 172                 LOGP(0, LOGL_ERROR, "couldn't create VTY\n");
 173                 close(new_connection);
 174                 talloc_free(connection);
 175                 return -1;
 176         }
 177
 178         return 0;
 179 }
 180
 181 /* callback from VTY code */
 182 void vty_event(enum event event, int sock, struct vty *vty)
 183 {
 184         struct telnet_connection *connection = vty->priv;
 185         struct bsc_fd *bfd = &connection->fd;
 186
 187         if (vty->type != VTY_TERM)
 188                 return;
 189
 190         switch (event) {
 191         case VTY_READ:
 192                 bfd->when |= BSC_FD_READ;
 193                 break;
 194         case VTY_WRITE:
 195                 bfd->when |= BSC_FD_WRITE;
 196                 break;
 197         case VTY_CLOSED:
 198                 /* vty layer is about to free() vty */
 199                 connection->vty = NULL;
 200                 telnet_close_client(bfd);
 201                 break;
 202         default:
 203                 break;
 204         }
 205 }
 206