src/stroke/stroke.c

   1 /* Stroke for charon is the counterpart to whack from pluto
   2  * Copyright (C) 2006 Martin Willi - Hochschule fuer Technik Rapperswil
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the
   6  * Free Software Foundation; either version 2 of the License, or (at your
   7  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * for more details.
  13  */
  14
  15 #include <stdlib.h>
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18 #include <sys/socket.h>
  19 #include <sys/un.h>
  20 #include <sys/fcntl.h>
  21 #include <unistd.h>
  22 #include <dirent.h>
  23 #include <errno.h>
  24 #include <stdio.h>
  25 #include <stddef.h>
  26
  27 #include "stroke.h"
  28 #include "stroke_keywords.h"
  29
  30 struct stroke_token {
  31     char *name;
  32     stroke_keyword_t kw;
  33 };
  34
  35 static char* push_string(stroke_msg_t *msg, char *string)
  36 {
  37         unsigned long string_start = msg->length;
  38
  39         if (string == NULL ||  msg->length + strlen(string) >= sizeof(stroke_msg_t))
  40         {
  41                 return NULL;
  42         }
  43         else
  44         {
  45                 msg->length += strlen(string) + 1;
  46                 strcpy((char*)msg + string_start, string);
  47                 return (char*)string_start;
  48         }
  49 }
  50
  51 static int send_stroke_msg (stroke_msg_t *msg)
  52 {
  53         struct sockaddr_un ctl_addr = { AF_UNIX, STROKE_SOCKET };
  54         int sock;
  55         char buffer[64];
  56         int byte_count;
  57
  58         msg->output_verbosity = 1; /* CONTROL */
  59
  60         sock = socket(AF_UNIX, SOCK_STREAM, 0);
  61         if (sock < 0)
  62         {
  63                 fprintf(stderr, "Opening unix socket %s: %s\n", STROKE_SOCKET, strerror(errno));
  64                 return -1;
  65         }
  66         if (connect(sock, (struct sockaddr *)&ctl_addr,
  67                                 offsetof(struct sockaddr_un, sun_path) + strlen(ctl_addr.sun_path)) < 0)
  68         {
  69                 fprintf(stderr, "Connect to socket failed: %s\n", strerror(errno));
  70                 close(sock);
  71                 return -1;
  72         }
  73
  74         /* send message */
  75         if (write(sock, msg, msg->length) != msg->length)
  76         {
  77                 fprintf(stderr, "writing to socket failed: %s\n", strerror(errno));
  78                 close(sock);
  79                 return -1;
  80         }
  81
  82         while ((byte_count = read(sock, buffer, sizeof(buffer)-1)) > 0)
  83         {
  84                 buffer[byte_count] = '\0';
  85                 printf("%s", buffer);
  86         }
  87         if (byte_count < 0)
  88         {
  89                 fprintf(stderr, "reading from socket failed: %s\n", strerror(errno));
  90         }
  91
  92         close(sock);
  93         return 0;
  94 }
  95
  96 static int add_connection(char *name,
  97                                                   char *my_id, char *other_id,
  98                                                   char *my_addr, char *other_addr,
  99                                                   char *my_net, char *other_net,
 100                                                   u_int my_netmask, u_int other_netmask)
 101 {
 102         stroke_msg_t msg;
 103
 104         msg.length = offsetof(stroke_msg_t, buffer);
 105         msg.type = STR_ADD_CONN;
 106
 107         msg.add_conn.name = push_string(&msg, name);
 108         msg.add_conn.ikev2 = 1;
 109
 110         msg.add_conn.rekey.reauth = 0;
 111         msg.add_conn.rekey.ipsec_lifetime = 0;
 112         msg.add_conn.rekey.ike_lifetime = 0;
 113         msg.add_conn.rekey.margin = 0;
 114         msg.add_conn.rekey.tries = 0;
 115         msg.add_conn.rekey.fuzz = 0;
 116
 117         msg.add_conn.algorithms.ike = NULL;
 118         msg.add_conn.algorithms.esp = NULL;
 119
 120         msg.add_conn.dpd.delay = 0;
 121         msg.add_conn.dpd.action = 1;
 122
 123         msg.add_conn.me.id = push_string(&msg, my_id);
 124         msg.add_conn.me.address = push_string(&msg, my_addr);
 125         msg.add_conn.me.subnet = push_string(&msg, my_net);
 126         msg.add_conn.me.subnet_mask = my_netmask;
 127         msg.add_conn.me.cert = NULL;
 128         msg.add_conn.me.ca = NULL;
 129         msg.add_conn.me.sendcert = 1;
 130         msg.add_conn.me.hostaccess = 0;
 131         msg.add_conn.me.protocol = 0;
 132         msg.add_conn.me.port = 0;
 133
 134         msg.add_conn.other.id = push_string(&msg, other_id);
 135         msg.add_conn.other.address = push_string(&msg, other_addr);
 136         msg.add_conn.other.subnet = push_string(&msg, other_net);
 137         msg.add_conn.other.subnet_mask = other_netmask;
 138         msg.add_conn.other.cert = NULL;
 139         msg.add_conn.other.ca = NULL;
 140         msg.add_conn.other.sendcert = 1;
 141         msg.add_conn.other.hostaccess = 0;
 142         msg.add_conn.other.protocol = 0;
 143         msg.add_conn.other.port = 0;
 144
 145         return send_stroke_msg(&msg);
 146 }
 147
 148 static int del_connection(char *name)
 149 {
 150         stroke_msg_t msg;
 151
 152         msg.length = offsetof(stroke_msg_t, buffer);
 153         msg.type = STR_DEL_CONN;
 154         msg.initiate.name = push_string(&msg, name);
 155         return send_stroke_msg(&msg);
 156 }
 157
 158 static int initiate_connection(char *name)
 159 {
 160         stroke_msg_t msg;
 161
 162         msg.length = offsetof(stroke_msg_t, buffer);
 163         msg.type = STR_INITIATE;
 164         msg.initiate.name = push_string(&msg, name);
 165         return send_stroke_msg(&msg);
 166 }
 167
 168 static int terminate_connection(char *name)
 169 {
 170         stroke_msg_t msg;
 171
 172         msg.type = STR_TERMINATE;
 173         msg.length = offsetof(stroke_msg_t, buffer);
 174         msg.initiate.name = push_string(&msg, name);
 175         return send_stroke_msg(&msg);
 176 }
 177
 178 static int route_connection(char *name)
 179 {
 180         stroke_msg_t msg;
 181
 182         msg.type = STR_ROUTE;
 183         msg.length = offsetof(stroke_msg_t, buffer);
 184         msg.route.name = push_string(&msg, name);
 185         return send_stroke_msg(&msg);
 186 }
 187
 188 static int unroute_connection(char *name)
 189 {
 190         stroke_msg_t msg;
 191
 192         msg.type = STR_UNROUTE;
 193         msg.length = offsetof(stroke_msg_t, buffer);
 194         msg.unroute.name = push_string(&msg, name);
 195         return send_stroke_msg(&msg);
 196 }
 197
 198 static int show_status(stroke_keyword_t kw, char *connection)
 199 {
 200         stroke_msg_t msg;
 201
 202         msg.type = (kw == STROKE_STATUS)? STR_STATUS:STR_STATUS_ALL;
 203         msg.length = offsetof(stroke_msg_t, buffer);
 204         msg.status.name = push_string(&msg, connection);
 205         return send_stroke_msg(&msg);
 206 }
 207
 208 static int list_flags[] = {
 209         LIST_CERTS,
 210         LIST_CACERTS,
 211         LIST_CRLS,
 212         LIST_ALL
 213 };
 214
 215 static int list(stroke_keyword_t kw, int utc)
 216 {
 217         stroke_msg_t msg;
 218
 219         msg.type = STR_LIST;
 220         msg.length = offsetof(stroke_msg_t, buffer);
 221         msg.list.utc = utc;
 222         msg.list.flags = list_flags[kw - STROKE_LIST_FIRST];
 223         return send_stroke_msg(&msg);
 224 }
 225
 226 static int reread_flags[] = {
 227         REREAD_CACERTS,
 228         REREAD_CRLS,
 229         REREAD_ALL
 230 };
 231
 232 static int reread(stroke_keyword_t kw)
 233 {
 234         stroke_msg_t msg;
 235
 236         msg.type = STR_REREAD;
 237         msg.length = offsetof(stroke_msg_t, buffer);
 238         msg.reread.flags = reread_flags[kw - STROKE_REREAD_FIRST];
 239         return send_stroke_msg(&msg);
 240 }
 241
 242 static int set_loglevel(char *type, u_int level)
 243 {
 244         stroke_msg_t msg;
 245
 246         msg.type = STR_LOGLEVEL;
 247         msg.length = offsetof(stroke_msg_t, buffer);
 248         msg.loglevel.type = push_string(&msg, type);
 249         msg.loglevel.level = level;
 250         return send_stroke_msg(&msg);
 251 }
 252
 253 static void exit_error(char *error)
 254 {
 255         if (error)
 256         {
 257                 fprintf(stderr, "%s\n", error);
 258         }
 259         exit(-1);
 260 }
 261
 262 static void exit_usage(char *error)
 263 {
 264         printf("Usage:\n");
 265         printf("  Add a connection:\n");
 266         printf("    stroke add NAME MY_ID OTHER_ID MY_ADDR OTHER_ADDR\\\n");
 267         printf("           MY_NET OTHER_NET MY_NETBITS OTHER_NETBITS\n");
 268         printf("    where: ID is any IKEv2 ID \n");
 269         printf("           ADDR is a IPv4 address\n");
 270         printf("           NET is a IPv4 address of the subnet to tunnel\n");
 271         printf("           NETBITS is the size of the subnet, as the \"24\" in 192.168.0.0/24\n");
 272         printf("  Delete a connection:\n");
 273         printf("    stroke delete NAME\n");
 274         printf("    where: NAME is a connection name added with \"stroke add\"\n");
 275         printf("  Initiate a connection:\n");
 276         printf("    stroke up NAME\n");
 277         printf("    where: NAME is a connection name added with \"stroke add\"\n");
 278         printf("  Terminate a connection:\n");
 279         printf("    stroke down NAME\n");
 280         printf("    where: NAME is a connection name added with \"stroke add\"\n");
 281         printf("  Set loglevel for a logging type:\n");
 282         printf("    stroke loglevel TYPE LEVEL\n");
 283         printf("    where: TYPE is any|dmn|mgr|ike|chd|job|cfg|knl|net|enc|lib\n");
 284         printf("           LEVEL is -1|0|1|2|3|4\n");
 285         printf("  Show connection status:\n");
 286         printf("    stroke status\n");
 287         printf("  Show list of locally loaded certificates and crls:\n");
 288         printf("    stroke listcerts|listcacerts|listcrls|listall\n");
 289         printf("  Reload ca certificates and crls:\n");
 290         printf("    stroke rereadcacerts|rereadcrls|rereadall\n");
 291         exit_error(error);
 292 }
 293
 294 int main(int argc, char *argv[])
 295 {
 296         const stroke_token_t *token;
 297         int res = 0;
 298
 299         if (argc < 2)
 300         {
 301                 exit_usage(NULL);
 302         }
 303
 304         token = in_word_set(argv[1], strlen(argv[1]));
 305
 306         if (token == NULL)
 307         {
 308                 exit_usage("unknown keyword");
 309         }
 310
 311         switch (token->kw)
 312         {
 313                 case STROKE_ADD:
 314                         if (argc < 11)
 315                         {
 316                                 exit_usage("\"add\" needs more parameters...");
 317                         }
 318                         res = add_connection(argv[2],
 319                                                                  argv[3], argv[4],
 320                                                                  argv[5], argv[6],
 321                                                                  argv[7], argv[8],
 322                                                                  atoi(argv[9]), atoi(argv[10]));
 323                         break;
 324                 case STROKE_DELETE:
 325                 case STROKE_DEL:
 326                         if (argc < 3)
 327                         {
 328                                 exit_usage("\"delete\" needs a connection name");
 329                         }
 330                         res = del_connection(argv[2]);
 331                         break;
 332                 case STROKE_UP:
 333                         if (argc < 3)
 334                         {
 335                                 exit_usage("\"up\" needs a connection name");
 336                         }
 337                         res = initiate_connection(argv[2]);
 338                         break;
 339                 case STROKE_DOWN:
 340                         if (argc < 3)
 341                         {
 342                                 exit_usage("\"down\" needs a connection name");
 343                         }
 344                         res = terminate_connection(argv[2]);
 345                         break;
 346                 case STROKE_ROUTE:
 347                         if (argc < 3)
 348                         {
 349                                 exit_usage("\"route\" needs a connection name");
 350                         }
 351                         res = route_connection(argv[2]);
 352                         break;
 353                 case STROKE_UNROUTE:
 354                         if (argc < 3)
 355                         {
 356                                 exit_usage("\"unroute\" needs a connection name");
 357                         }
 358                         res = unroute_connection(argv[2]);
 359                         break;
 360                 case STROKE_LOGLEVEL:
 361                         if (argc < 4)
 362                         {
 363                                 exit_usage("\"logtype\" needs more parameters...");
 364                         }
 365                         res = set_loglevel(argv[2], atoi(argv[3]));
 366                         break;
 367                 case STROKE_STATUS:
 368                 case STROKE_STATUSALL:
 369                         res = show_status(token->kw, argc > 2 ? argv[2] : NULL);
 370                         break;
 371                 case STROKE_LIST_CERTS:
 372                 case STROKE_LIST_CACERTS:
 373                 case STROKE_LIST_CRLS:
 374                 case STROKE_LIST_ALL:
 375                         res = list(token->kw, argc > 2 && strcmp(argv[2], "--utc") == 0);
 376                         break;
 377                 case STROKE_REREAD_CACERTS:
 378                 case STROKE_REREAD_CRLS:
 379                 case STROKE_REREAD_ALL:
 380                         res = reread(token->kw);
 381                         break;
 382                 default:
 383                         exit_usage(NULL);
 384         }
 385         return res;
 386 }