]> git.meshlink.io Git - meshlink/commitdiff
Fancier protocol for control socket
authorScott Lamb <slamb@slamb.org>
Wed, 7 Nov 2007 02:48:33 +0000 (02:48 +0000)
committerScott Lamb <slamb@slamb.org>
Wed, 7 Nov 2007 02:48:33 +0000 (02:48 +0000)
* pass error status back
* pass message boundaries

src/control.c
src/control_common.h [new file with mode: 0644]
src/tincctl.c

index b3cce92853d43764a7b8fd10c192a647ce76080a..7b27f69afe8f4f956b88cc4298febe553e5da37d 100644 (file)
@@ -24,6 +24,7 @@
 #include "system.h"
 #include "conf.h"
 #include "control.h"
+#include "control_common.h"
 #include "logger.h"
 #include "xalloc.h"
 
@@ -33,17 +34,58 @@ static splay_tree_t *control_socket_tree;
 extern char *controlsocketname;
 
 static void handle_control_data(struct bufferevent *event, void *data) {
-       char *line = evbuffer_readline(event->input);
-       if(!line)
+       tinc_ctl_request_t req;
+       size_t size;
+       tinc_ctl_request_t res;
+       struct evbuffer *res_data = NULL;
+
+       if(EVBUFFER_LENGTH(event->input) < sizeof(tinc_ctl_request_t))
                return;
-       
-       if(!strcasecmp(line, "stop")) {
+
+       /* Copy the structure to ensure alignment */
+       memcpy(&req, EVBUFFER_DATA(event->input), sizeof(tinc_ctl_request_t));
+
+       if(EVBUFFER_LENGTH(event->input) < req.length)
+               return;
+
+       if(req.length < sizeof(tinc_ctl_request_t))
+               goto failure;
+
+       memset(&res, 0, sizeof res);
+       res.type = req.type;
+       res.id = req.id;
+
+       res_data = evbuffer_new();
+       if (res_data == NULL) {
+               res.res_errno = ENOMEM;
+               goto respond;
+       }
+
+       if(req.type == REQ_STOP) {
                logger(LOG_NOTICE, _("Got stop command"));
                event_loopexit(NULL);
-               return;
+               goto respond;
        }
 
        logger(LOG_DEBUG, _("Malformed control command received"));
+       res.res_errno = EINVAL;
+
+respond:
+       res.length = (sizeof res)
+                                + ((res_data == NULL) ? 0 : EVBUFFER_LENGTH(res_data));
+       evbuffer_drain(event->input, req.length);
+       if(bufferevent_write(event, &res, sizeof res) == -1)
+               goto failure;
+       if(res_data != NULL) {
+               if(bufferevent_write_buffer(event, res_data) == -1)
+                       goto failure;
+               evbuffer_free(res_data);
+       }
+       return;
+
+failure:
+       logger(LOG_INFO, _("Closing control socket on error"));
+       evbuffer_free(res_data);
        close(event->ev_read.ev_fd);
        splay_delete(control_socket_tree, event);
 }
@@ -61,6 +103,7 @@ static void handle_control_error(struct bufferevent *event, short what, void *da
 static void handle_new_control_socket(int fd, short events, void *data) {
        int newfd;
        struct bufferevent *ev;
+       tinc_ctl_greeting_t greeting;
 
        newfd = accept(fd, NULL, NULL);
 
@@ -77,6 +120,17 @@ static void handle_new_control_socket(int fd, short events, void *data) {
                return;
        }
 
+       memset(&greeting, 0, sizeof greeting);
+       greeting.version = TINC_CTL_VERSION_CURRENT;
+       if(bufferevent_write(ev, &greeting, sizeof greeting) == -1) {
+               logger(LOG_ERR,
+                          _("Cannot send greeting for new control connection: %s"),
+                          strerror(errno));
+               bufferevent_free(ev);
+               close(newfd);
+               return;
+       }
+
        bufferevent_enable(ev, EV_READ);
        splay_insert(control_socket_tree, ev);
 
diff --git a/src/control_common.h b/src/control_common.h
new file mode 100644 (file)
index 0000000..3fa034e
--- /dev/null
@@ -0,0 +1,46 @@
+/*
+    control_protocol.h -- control socket protocol.
+    Copyright (C) 2007 Scott Lamb <slamb@slamb.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    $Id$
+*/
+
+#ifndef __TINC_CONTROL_PROTOCOL_H__
+#define __TINC_CONTROL_PROTOCOL_H__
+
+enum request_type {
+       REQ_STOP,
+       REQ_RELOAD,
+       REQ_RESTART,
+};
+
+#define TINC_CTL_VERSION_CURRENT 0
+
+/* This greeting is sent by the server on socket open. */
+typedef struct tinc_ctl_greeting_t {
+       int version;
+} tinc_ctl_greeting_t;
+
+/* A single request or response header. */
+typedef struct tinc_ctl_request_t {
+       size_t length; /* total length, including the header */
+       enum request_type type;
+       int id;
+       int res_errno; /* used only for responses */
+} tinc_ctl_request_t;
+
+#endif
index 5d65f3aa51d19812fde231f317c7a56472793ffe..3944fa2e96f516136e043fb13cadd9752a567996 100644 (file)
@@ -30,8 +30,9 @@
 
 #include <getopt.h>
 
-#include "protocol.h"
 #include "xalloc.h"
+#include "protocol.h"
+#include "control_common.h"
 
 /* The name this program was run with. */
 char *program_name = NULL;
@@ -327,9 +328,118 @@ static void make_names(void) {
        }
 }
 
+static int fullread(int fd, void *data, size_t datalen) {
+       int rv, len = 0;
+
+       while (len < datalen) {
+               rv = read(fd, data + len, datalen - len);
+               if(rv == -1 && errno == EINTR)
+                       continue;
+               else if (rv == -1)
+                       return rv;
+               else if (rv == 0) {
+                       errno = ENODATA;
+                       return -1;
+               }
+               len += rv;
+       }
+       return 0;
+}
+
+/*
+   Send a request (raw)
+*/
+static int send_ctl_request(int fd, enum request_type type,
+                                                  void const *outdata, size_t outdatalen,
+                                                  int *res_errno_p, void **indata_p,
+                                                  size_t *indatalen_p) {
+       tinc_ctl_request_t req;
+       int rv;
+       struct iovec vector[2] = {
+               {&req, sizeof(req)},
+               {(void*) outdata, outdatalen}
+       };
+       void *indata;
+
+       if(res_errno_p == NULL)
+               return -1;
+
+       memset(&req, 0, sizeof req);
+       req.length = sizeof req + outdatalen;
+       req.type = type;
+       req.res_errno = 0;
+
+       while((rv = writev(fd, vector, 2)) == -1 && errno == EINTR) ;
+       if(rv != req.length)
+               return -1;
+
+       if(fullread(fd, &req, sizeof req) == -1)
+               return -1;
+
+       if(req.length < sizeof req) {
+               errno = EINVAL;
+               return -1;
+       }
+
+       if(req.length > sizeof req) {
+               if (indata_p == NULL) {
+                       errno = EINVAL;
+                       return -1;
+               }
+
+               indata = xmalloc(req.length - sizeof req);
+
+               if(fullread(fd, indata, req.length - sizeof req) == -1) {
+                       free(indata);
+                       return -1;
+               }
+
+               *indata_p = indata;
+               if(indatalen_p != NULL)
+                       *indatalen_p = req.length - sizeof req;
+       }
+
+       *res_errno_p = req.res_errno;
+
+       return 0;
+}
+
+/*
+   Send a request (with printfs)
+*/
+static int send_ctl_request_cooked(int fd, enum request_type type,
+                                                                  void const *outdata, size_t outdatalen)
+{
+       int res_errno = -1;
+       char *buf = NULL;
+       size_t buflen = 0;
+
+       if(send_ctl_request(fd, type, outdata, outdatalen, &res_errno,
+                                               (void**) &buf, &buflen)) {
+               fprintf(stderr, _("Error sending request: %s\n"), strerror(errno));
+               return -1;
+       }
+
+       if(buf != NULL) {
+               printf("%*s", buflen, buf);
+               free(buf);
+       }
+
+       if(res_errno != 0) {
+               fprintf(stderr, _("Server reported error: %s\n"), strerror(res_errno));
+               return -1;
+       }
+
+       return 0;
+}
+
 int main(int argc, char *argv[], char *envp[]) {
-       int fd;
        struct sockaddr_un addr;
+       int fd;
+       int len;
+       tinc_ctl_greeting_t greeting;
+       tinc_ctl_request_t req;
+
        program_name = argv[0];
 
        setlocale(LC_ALL, "");
@@ -399,6 +509,18 @@ int main(int argc, char *argv[], char *envp[]) {
                return 1;
        }
 
+       if(fullread(fd, &greeting, sizeof greeting) == -1) {
+               fprintf(stderr, _("Cannot read greeting from control socket: %s\n"),
+                               strerror(errno));
+               return 1;
+       }
+
+       if(greeting.version != TINC_CTL_VERSION_CURRENT) {
+               fprintf(stderr, _("Version mismatch: server %d, client %d\n"),
+                               greeting.version, TINC_CTL_VERSION_CURRENT);
+               return 1;
+       }
+
        struct ucred cred;
        socklen_t credlen = sizeof cred;
 
@@ -413,18 +535,15 @@ int main(int argc, char *argv[], char *envp[]) {
        }
 
        if(!strcasecmp(argv[optind], "stop")) {
-               write(fd, "stop\n", 5);
-               return 0;
+               return send_ctl_request_cooked(fd, REQ_STOP, NULL, 0) != -1;
        }
 
        if(!strcasecmp(argv[optind], "reload")) {
-               write(fd, "reload\n", 7);
-               return 0;
+               return send_ctl_request_cooked(fd, REQ_RELOAD, NULL, 0) != -1;
        }
        
        if(!strcasecmp(argv[optind], "restart")) {
-               write(fd, "restart\n", 8);
-               return 0;
+               return send_ctl_request_cooked(fd, REQ_RESTART, NULL, 0) != -1;
        }
 
        fprintf(stderr, _("Unknown command `%s'.\n"), argv[optind]);