Source/charon/payloads/ike_header.c

   1 /**
   2  * @file ike_header.c
   3  *
   4  * @brief Declaration of the class ike_header_t.
   5  *
   6  * An object of this type represents an ike header and is used to
   7  * generate and parse ike headers.
   8  *
   9  */
  10
  11 /*
  12  * Copyright (C) 2005 Jan Hutter, Martin Willi
  13  * Hochschule fuer Technik Rapperswil
  14  *
  15  * This program is free software; you can redistribute it and/or modify it
  16  * under the terms of the GNU General Public License as published by the
  17  * Free Software Foundation; either version 2 of the License, or (at your
  18  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
  19  *
  20  * This program is distributed in the hope that it will be useful, but
  21  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  22  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  23  * for more details.
  24  */
  25
  26 /* offsetof macro */
  27 #include <stddef.h>
  28
  29 #include "ike_header.h"
  30
  31 #include "encodings.h"
  32 #include "../utils/allocator.h"
  33
  34 typedef struct private_ike_header_s private_ike_header_t;
  35
  36 struct private_ike_header_s {
  37         /**
  38          * public interface
  39          */
  40         ike_header_t public;
  41
  42         /**
  43          * SPI of the initiator
  44          */
  45         u_int64_t initiator_spi;
  46         /**
  47          * SPI of the responder
  48          */
  49         u_int64_t responder_spi;
  50         /**
  51          * next payload type
  52          */
  53         u_int8_t  next_payload;
  54         /**
  55          * IKE major version
  56          */
  57         u_int8_t  maj_version;
  58
  59         /**
  60          * IKE minor version
  61          */
  62         u_int8_t  min_version;
  63
  64         /**
  65          * Exchange type
  66          */
  67         u_int8_t  exchange_type;
  68
  69         /**
  70          * Flags of the Message
  71          *
  72          */
  73         struct {
  74                 /**
  75                  * Sender is initiator of the associated IKE_SA_INIT-Exchange
  76                  */
  77                 bool initiator;
  78                 /**
  79                  * is protocol supporting higher version?
  80                  */
  81                 bool version;
  82                 /**
  83                  * TRUE, if this is a response, FALSE if its a Request
  84                  */
  85                 bool response;
  86         } flags;
  87         /**
  88          * Associated Message-ID
  89          */
  90         u_int32_t message_id;
  91         /**
  92          * Length of the whole IKEv2-Message (header and all payloads)
  93          */
  94         u_int32_t length;
  95 };
  96
  97
  98
  99 /**
 100  * Encoding rules to parse or generate a IKEv2-Header
 101  *
 102  * The defined offsets are the positions in a object of type
 103  * ike_header_t.
 104  *
 105  */
 106 encoding_rule_t ike_header_encodings[] = {
 107         /* 8 Byte SPI, stored in the field initiator_spi */
 108         { U_INT_64,             offsetof(private_ike_header_t, initiator_spi)   },
 109         /* 8 Byte SPI, stored in the field responder_spi */
 110         { U_INT_64,             offsetof(private_ike_header_t, responder_spi)   },
 111         /* 1 Byte next payload type, stored in the field next_payload */
 112         { U_INT_8,              offsetof(private_ike_header_t, next_payload)    },
 113         /* 4 Bit major version, stored in the field maj_version */
 114         { U_INT_4,              offsetof(private_ike_header_t, maj_version)     },
 115         /* 4 Bit minor version, stored in the field min_version */
 116         { U_INT_4,              offsetof(private_ike_header_t, min_version)     },
 117         /* 8 Bit for the exchange type */
 118         { U_INT_8,              offsetof(private_ike_header_t, exchange_type)   },
 119         /* 2 Bit reserved bits, nowhere stored */
 120         { RESERVED_BIT, 0                                                                               },
 121         { RESERVED_BIT, 0                                                                               },
 122         /* 3 Bit flags, stored in the fields response, version and initiator */
 123         { FLAG,                 offsetof(private_ike_header_t, flags.response)  },
 124         { FLAG,                 offsetof(private_ike_header_t, flags.version)   },
 125         { FLAG,                 offsetof(private_ike_header_t, flags.initiator) },
 126         /* 3 Bit reserved bits, nowhere stored */
 127         { RESERVED_BIT, 0                                                                               },
 128         { RESERVED_BIT, 0                                                                               },
 129         { RESERVED_BIT, 0                                                                               },
 130         /* 4 Byte message id, stored in the field message_id */
 131         { U_INT_32,             offsetof(private_ike_header_t, message_id)              },
 132         /* 4 Byte length fied, stored in the field length */
 133         { HEADER_LENGTH,        offsetof(private_ike_header_t, length)                  }
 134 };
 135
 136 /**
 137  * Implements ike_header_t's get_next_payload fuction.
 138  * See #ike_header_t.get_next_payload  for description.
 139  */
 140 static u_int8_t get_next_payload(private_ike_header_t *this)
 141 {
 142         return this->next_payload;
 143 }
 144
 145 /**
 146  * Implements ike_header_t's set_next_payload fuction.
 147  * See #ike_header_t.set_next_payload  for description.
 148  */
 149 static void set_next_payload(private_ike_header_t *this, u_int8_t next_payload)
 150 {
 151         this->next_payload = next_payload;
 152 }
 153
 154 /**
 155  * Implements ike_header_t's get_initiator_spi fuction.
 156  * See #ike_header_t.get_initiator_spi  for description.
 157  */
 158 static u_int64_t get_initiator_spi(private_ike_header_t *this)
 159 {
 160         return this->initiator_spi;
 161 }
 162
 163 /**
 164  * Implements ike_header_t's set_initiator_spi fuction.
 165  * See #ike_header_t.set_initiator_spi  for description.
 166  */
 167 static void set_initiator_spi(private_ike_header_t *this, u_int64_t initiator_spi)
 168 {
 169         this->initiator_spi = initiator_spi;
 170 }
 171
 172 /**
 173  * Implements ike_header_t's get_responder_spi fuction.
 174  * See #ike_header_t.get_responder_spi  for description.
 175  */
 176 static u_int64_t get_responder_spi(private_ike_header_t *this)
 177 {
 178         return this->responder_spi;
 179 }
 180
 181 /**
 182  * Implements ike_header_t's set_responder_spi fuction.
 183  * See #ike_header_t.set_responder_spi  for description.
 184  */
 185 static void set_responder_spi(private_ike_header_t *this, u_int64_t responder_spi)
 186 {
 187         this->responder_spi = responder_spi;
 188 }
 189
 190 /**
 191  * Implements ike_header_t's get_maj_version fuction.
 192  * See #ike_header_t.get_maj_version  for description.
 193  */
 194 static u_int8_t get_maj_version(private_ike_header_t *this)
 195 {
 196         return this->maj_version;
 197 }
 198
 199 /**
 200  * Implements ike_header_t's get_min_version fuction.
 201  * See #ike_header_t.get_min_version  for description.
 202  */
 203 static u_int8_t get_min_version(private_ike_header_t *this)
 204 {
 205         return this->min_version;
 206 }
 207
 208 /**
 209  * Implements ike_header_t's get_response_flag fuction.
 210  * See #ike_header_t.get_response_flag  for description.
 211  */
 212 static bool get_response_flag(private_ike_header_t *this)
 213 {
 214         return this->flags.response;
 215 }
 216
 217 /**
 218  * Implements ike_header_t's set_response_flag fuction.
 219  * See #ike_header_t.set_response_flag  for description.
 220  */
 221 static void set_response_flag(private_ike_header_t *this, bool response)
 222 {
 223         this->flags.response = response;
 224 }
 225
 226 /**
 227  * Implements ike_header_t's get_version_flag fuction.
 228  * See #ike_header_t.get_version_flag  for description.
 229  */
 230 static bool get_version_flag(private_ike_header_t *this)
 231 {
 232         return this->flags.version;
 233 }
 234
 235 /**
 236  * Implements ike_header_t's get_initiator_flag fuction.
 237  * See #ike_header_t.get_initiator_flag  for description.
 238  */
 239 static bool get_initiator_flag(private_ike_header_t *this)
 240 {
 241         return this->flags.initiator;
 242 }
 243
 244 /**
 245  * Implements ike_header_t's set_initiator_flag fuction.
 246  * See #ike_header_t.set_initiator_flag  for description.
 247  */
 248 static void set_initiator_flag(private_ike_header_t *this, bool initiator)
 249 {
 250         this->flags.initiator = initiator;
 251 }
 252
 253 /**
 254  * Implements ike_header_t's get_exchange_type function
 255  * See #ike_header_t.get_exchange_type  for description.
 256  */
 257 static u_int8_t get_exchange_type(private_ike_header_t *this)
 258 {
 259         return this->exchange_type;
 260 }
 261
 262 /**
 263  * Implements ike_header_t's set_exchange_type function.
 264  * See #ike_header_t.set_exchange_type  for description.
 265  */
 266 static void set_exchange_type(private_ike_header_t *this, u_int8_t exchange_type)
 267 {
 268         this->exchange_type = exchange_type;
 269 }
 270
 271 /**
 272  * Implements ike_header_t's get_message_id function.
 273  * See #ike_header_t.get_message_id  for description.
 274  */
 275 static u_int32_t get_message_id(private_ike_header_t *this)
 276 {
 277         return this->message_id;
 278 }
 279
 280 /**
 281  * Implements ike_header_t's set_message_id function.
 282  * See #ike_header_t.set_message_id  for description.
 283  */
 284 static void set_message_id(private_ike_header_t *this, u_int32_t message_id)
 285 {
 286         this->message_id = message_id;
 287 }
 288
 289 /**
 290  * Implements payload_t's and ike_header_t's destroy function.
 291  * See #payload_s.destroy or ike_header_s.destroy for description.
 292  */
 293 static status_t destroy(ike_header_t *this)
 294 {
 295         allocator_free(this);
 296
 297         return SUCCESS;
 298 }
 299
 300 /**
 301  * Implements payload_t's get_encoding_rules function.
 302  * See #payload_s.get_encoding_rules for description.
 303  */
 304 static status_t get_encoding_rules(payload_t *this, encoding_rule_t **rules, size_t *rule_count)
 305 {
 306         *rules = ike_header_encodings;
 307         *rule_count = sizeof(ike_header_encodings) / sizeof(encoding_rule_t);
 308
 309         return SUCCESS;
 310 }
 311
 312 /**
 313  * Implements payload_t's get_type function.
 314  * See #payload_s.get_type for description.
 315  */
 316 static payload_type_t get_type(payload_t *this)
 317 {
 318         return HEADER;
 319 }
 320
 321 /**
 322  * Implements payload_t's get_next_type function.
 323  * See #payload_s.get_next_type for description.
 324  */
 325 static payload_type_t get_next_type(payload_t *this)
 326 {
 327         return (((private_ike_header_t*)this)->next_payload);
 328 }
 329
 330 /**
 331  * Implements payload_t's get_length function.
 332  * See #payload_s.get_length for description.
 333  */
 334 static size_t get_length(payload_t *this)
 335 {
 336         return (((private_ike_header_t*)this)->length);
 337 }
 338
 339 /*
 340  * Described in header
 341  */
 342 ike_header_t *ike_header_create()
 343 {
 344         private_ike_header_t *this = allocator_alloc_thing(private_ike_header_t);
 345         if (this == NULL)
 346         {
 347                 return NULL;
 348         }
 349
 350         this->public.payload_interface.get_encoding_rules = get_encoding_rules;
 351         this->public.payload_interface.get_length = get_length;
 352         this->public.payload_interface.get_next_type = get_next_type;
 353         this->public.payload_interface.get_type = get_type;
 354         this->public.payload_interface.destroy = (status_t (*) (payload_t *))destroy;
 355         this->public.destroy = destroy;
 356
 357
 358         this->public.get_next_payload = (u_int8_t (*) (ike_header_t*))get_next_payload;
 359         this->public.set_next_payload = (void (*) (ike_header_t*,u_int8_t))set_next_payload;
 360         this->public.get_initiator_spi = (u_int64_t (*) (ike_header_t*))get_initiator_spi;
 361         this->public.set_initiator_spi = (void (*) (ike_header_t*,u_int64_t))set_initiator_spi;
 362         this->public.get_responder_spi = (u_int64_t (*) (ike_header_t*))get_responder_spi;
 363         this->public.set_responder_spi = (void (*) (ike_header_t *,u_int64_t))set_responder_spi;
 364         this->public.get_maj_version = (u_int8_t (*) (ike_header_t*))get_maj_version;
 365         this->public.get_min_version = (u_int8_t (*) (ike_header_t*))get_min_version;
 366         this->public.get_response_flag = (bool (*) (ike_header_t*))get_response_flag;
 367         this->public.set_response_flag = (void (*) (ike_header_t*,bool))set_response_flag;
 368         this->public.get_version_flag = (bool (*) (ike_header_t*))get_version_flag;
 369         this->public.get_initiator_flag = (bool (*) (ike_header_t*))get_initiator_flag;
 370         this->public.set_initiator_flag = (void (*) (ike_header_t*,bool))set_initiator_flag;
 371         this->public.get_exchange_type = (u_int8_t (*) (ike_header_t*))get_exchange_type;
 372         this->public.set_exchange_type = (void (*) (ike_header_t*,u_int8_t))set_exchange_type;
 373         this->public.get_message_id = (u_int32_t (*) (ike_header_t*))get_message_id;
 374         this->public.set_message_id = (void (*) (ike_header_t*,u_int32_t))set_message_id;
 375
 376         /* set default values of the fields */
 377         this->initiator_spi = 0;
 378         this->responder_spi = 0;
 379         this->next_payload = 0;
 380         this->maj_version = IKE_MAJOR_VERSION;
 381         this->min_version = IKE_MINOR_VERSION;
 382         this->exchange_type = NOT_SET;
 383         this->flags.initiator = TRUE;
 384         this->flags.version = HIGHER_VERSION_SUPPORTED_FLAG;
 385         this->flags.response = FALSE;
 386         this->message_id = 0;
 387         this->length = IKE_HEADER_LENGTH;
 388
 389
 390         return (ike_header_t*)this;
 391 }
 392
 393