tinc-vpn.org Git - tinc/blob - src/control.c

   1 /*
   2     control.c -- Control socket handling.
   3     Copyright (C) 2007 Guus Sliepen <guus@tinc-vpn.org>
   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
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19     $Id$
  20 */
  21
  22 #include <sys/un.h>
  23
  24 #include "system.h"
  25 #include "conf.h"
  26 #include "control.h"
  27 #include "control_common.h"
  28 #include "logger.h"
  29 #include "xalloc.h"
  30
  31 static int control_socket = -1;
  32 static struct event control_event;
  33 static splay_tree_t *control_socket_tree;
  34 extern char *controlsocketname;
  35
  36 static void handle_control_data(struct bufferevent *event, void *data) {
  37         tinc_ctl_request_t req;
  38         size_t size;
  39         tinc_ctl_request_t res;
  40         struct evbuffer *res_data = NULL;
  41
  42         if(EVBUFFER_LENGTH(event->input) < sizeof(tinc_ctl_request_t))
  43                 return;
  44
  45         /* Copy the structure to ensure alignment */
  46         memcpy(&req, EVBUFFER_DATA(event->input), sizeof(tinc_ctl_request_t));
  47
  48         if(EVBUFFER_LENGTH(event->input) < req.length)
  49                 return;
  50
  51         if(req.length < sizeof(tinc_ctl_request_t))
  52                 goto failure;
  53
  54         memset(&res, 0, sizeof res);
  55         res.type = req.type;
  56         res.id = req.id;
  57
  58         res_data = evbuffer_new();
  59         if (res_data == NULL) {
  60                 res.res_errno = ENOMEM;
  61                 goto respond;
  62         }
  63
  64         if(req.type == REQ_STOP) {
  65                 logger(LOG_NOTICE, _("Got stop command"));
  66                 event_loopexit(NULL);
  67                 goto respond;
  68         }
  69
  70         logger(LOG_DEBUG, _("Malformed control command received"));
  71         res.res_errno = EINVAL;
  72
  73 respond:
  74         res.length = (sizeof res)
  75                                  + ((res_data == NULL) ? 0 : EVBUFFER_LENGTH(res_data));
  76         evbuffer_drain(event->input, req.length);
  77         if(bufferevent_write(event, &res, sizeof res) == -1)
  78                 goto failure;
  79         if(res_data != NULL) {
  80                 if(bufferevent_write_buffer(event, res_data) == -1)
  81                         goto failure;
  82                 evbuffer_free(res_data);
  83         }
  84         return;
  85
  86 failure:
  87         logger(LOG_INFO, _("Closing control socket on error"));
  88         evbuffer_free(res_data);
  89         close(event->ev_read.ev_fd);
  90         splay_delete(control_socket_tree, event);
  91 }
  92
  93 static void handle_control_error(struct bufferevent *event, short what, void *data) {
  94         if(what & EVBUFFER_EOF)
  95                 logger(LOG_DEBUG, _("Control socket connection closed by peer"));
  96         else
  97                 logger(LOG_DEBUG, _("Error while reading from control socket: %s"), strerror(errno));
  98
  99         close(event->ev_read.ev_fd);
 100         splay_delete(control_socket_tree, event);
 101 }
 102
 103 static void handle_new_control_socket(int fd, short events, void *data) {
 104         int newfd;
 105         struct bufferevent *ev;
 106         tinc_ctl_greeting_t greeting;
 107
 108         newfd = accept(fd, NULL, NULL);
 109
 110         if(newfd < 0) {
 111                 logger(LOG_ERR, _("Accepting a new connection failed: %s"), strerror(errno));
 112                 event_del(&control_event);
 113                 return;
 114         }
 115
 116         ev = bufferevent_new(newfd, handle_control_data, NULL, handle_control_error, NULL);
 117         if(!ev) {
 118                 logger(LOG_ERR, _("Could not create bufferevent for new control connection: %s"), strerror(errno));
 119                 close(newfd);
 120                 return;
 121         }
 122
 123         memset(&greeting, 0, sizeof greeting);
 124         greeting.version = TINC_CTL_VERSION_CURRENT;
 125         if(bufferevent_write(ev, &greeting, sizeof greeting) == -1) {
 126                 logger(LOG_ERR,
 127                            _("Cannot send greeting for new control connection: %s"),
 128                            strerror(errno));
 129                 bufferevent_free(ev);
 130                 close(newfd);
 131                 return;
 132         }
 133
 134         bufferevent_enable(ev, EV_READ);
 135         splay_insert(control_socket_tree, ev);
 136
 137         logger(LOG_DEBUG, _("Control socket connection accepted"));
 138 }
 139
 140 static int control_compare(const struct event *a, const struct event *b) {
 141         return a < b ? -1 : a > b ? 1 : 0;
 142 }
 143
 144 bool init_control() {
 145         int result;
 146         struct sockaddr_un addr;
 147
 148         if(strlen(controlsocketname) >= sizeof addr.sun_path) {
 149                 logger(LOG_ERR, _("Control socket filename too long!"));
 150                 return false;
 151         }
 152
 153         memset(&addr, 0, sizeof addr);
 154         addr.sun_family = AF_UNIX;
 155         strncpy(addr.sun_path, controlsocketname, sizeof addr.sun_path - 1);
 156
 157         control_socket = socket(PF_UNIX, SOCK_STREAM, 0);
 158
 159         if(control_socket < 0) {
 160                 logger(LOG_ERR, _("Creating UNIX socket failed: %s"), strerror(errno));
 161                 return false;
 162         }
 163
 164         //unlink(controlsocketname);
 165         result = bind(control_socket, (struct sockaddr *)&addr, sizeof addr);
 166
 167         if(result < 0 && errno == EADDRINUSE) {
 168                 result = connect(control_socket, (struct sockaddr *)&addr, sizeof addr);
 169                 if(result < 0) {
 170                         logger(LOG_WARNING, _("Removing old control socket."));
 171                         unlink(controlsocketname);
 172                         result = bind(control_socket, (struct sockaddr *)&addr, sizeof addr);
 173                 } else {
 174                         close(control_socket);
 175                         if(netname)
 176                                 logger(LOG_ERR, _("Another tincd is already running for net `%s'."), netname);
 177                         else
 178                                 logger(LOG_ERR, _("Another tincd is already running."));
 179                         return false;
 180                 }
 181         }
 182
 183         if(result < 0) {
 184                 logger(LOG_ERR, _("Can't bind to %s: %s\n"), controlsocketname, strerror(errno));
 185                 close(control_socket);
 186                 return false;
 187         }
 188
 189         if(listen(control_socket, 3) < 0) {
 190                 logger(LOG_ERR, _("Can't listen on %s: %s\n"), controlsocketname, strerror(errno));
 191                 close(control_socket);
 192                 return false;
 193         }
 194
 195         control_socket_tree = splay_alloc_tree((splay_compare_t)control_compare, (splay_action_t)bufferevent_free);
 196
 197         event_set(&control_event, control_socket, EV_READ | EV_PERSIST, handle_new_control_socket, NULL);
 198         event_add(&control_event, NULL);
 199
 200         return true;
 201 }
 202
 203 void exit_control() {
 204         event_del(&control_event);
 205         close(control_socket);
 206         unlink(controlsocketname);
 207 }