src/stroke/stroke.c

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