Source/charon/generator.c

   1 /**
   2  * @file generator.c
   3  *
   4  * @brief Generic generator class used to generate IKEv2-Header and Payload
   5  *
   6  */
   7
   8 /*
   9  * Copyright (C) 2005 Jan Hutter, Martin Willi
  10  * Hochschule fuer Technik Rapperswil
  11  *
  12  * This program is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU General Public License as published by the
  14  * Free Software Foundation; either version 2 of the License, or (at your
  15  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
  16  *
  17  * This program is distributed in the hope that it will be useful, but
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  19  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20  * for more details.
  21  */
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <freeswan.h>
  26 #include <pluto/constants.h>
  27 #include <pluto/defs.h>
  28
  29 #include "allocator.h"
  30 #include "types.h"
  31 #include "generator.h"
  32
  33
  34 /**
  35  * buffer_t: used for geneartor operations
  36  */
  37 typedef struct generator_infos_s generator_infos_t;
  38
  39 struct generator_infos_s {
  40
  41         /**
  42          * Buffer used to generate to
  43          */
  44         u_int8_t *buffer;
  45
  46         /**
  47          * current write position in buffer (one byte alligned)
  48          */
  49         u_int8_t *out_position;
  50
  51         /**
  52          * position of last byte in buffer
  53          */
  54         u_int8_t *roof_position;
  55
  56         /**
  57          * Current bit writing to
  58          */
  59         size_t current_bit;
  60
  61         /**
  62          * Associated data struct to read informations from
  63          */
  64          void * data_struct;
  65         /**
  66          * @brief Destroys a generator_infos_t object
  67          *
  68          * @param generator_infos_t generator_infos_t object
  69          * @return SUCCESSFUL if succeeded, FAILED otherwise
  70          */
  71         status_t (*destroy) (generator_infos_t *this);
  72
  73         /**
  74          * Checks if enough space is available in buffer and if not,
  75          * the buffer size is increased until at least the asked amount of space
  76          * is available
  77          *
  78          * @param bits number of bits to make at leas available in buffer
  79          * @param generator_infos_t generator_infos_t object
  80          * @return SUCCESSFUL if succeeded, OUT_OF_RES otherwise
  81          */
  82         status_t (*make_space_available) (generator_infos_t *this,size_t bits);
  83
  84         status_t (*write_bytes_to_buffer) (generator_infos_t *this,void * bytes,size_t number_of_bytes);
  85
  86         status_t (*write_chunk) (generator_infos_t *this,chunk_t *data);
  87 };
  88
  89 /**
  90  * implements generator_infos_t's increase_buffer function
  91  */
  92 static status_t generator_info_make_space_available (generator_infos_t *this, size_t bits)
  93 {
  94         size_t free_bits = ((this->roof_position - this->out_position) * 8) - this->current_bit;
  95
  96         while (free_bits < bits)
  97         {
  98                 size_t old_buffer_size = ((this->roof_position) - (     this->buffer));
  99                 size_t new_buffer_size = old_buffer_size + GENERATOR_DATA_BUFFER_INCREASE_VALUE;
 100                 size_t out_position_offset = ((this->out_position) - (this->buffer));
 101                 u_int8_t *new_buffer;
 102
 103                 new_buffer = allocator_realloc(this->buffer,new_buffer_size);
 104                 if (new_buffer == NULL)
 105                 {
 106                         return OUT_OF_RES;
 107                 }
 108
 109                 this->buffer = new_buffer;
 110
 111                 this->out_position = (this->buffer + out_position_offset);
 112                 this->roof_position = (this->buffer + new_buffer_size);
 113         }
 114
 115         return SUCCESS;
 116 }
 117
 118 static status_t generator_info_write_bytes_to_buffer (generator_infos_t *this,void * bytes,size_t number_of_bytes)
 119 {
 120         u_int8_t *read_position = (u_int8_t *) bytes;
 121         int i;
 122         status_t status;
 123
 124         status = this->make_space_available(this,number_of_bytes * 8);
 125
 126         if (status != SUCCESS)
 127         {
 128                 return status;
 129         }
 130
 131         for (i = 0; i < number_of_bytes; i++)
 132         {
 133                 *(this->out_position) = *(read_position);
 134                 read_position++;
 135                 this->out_position++;
 136         }
 137         return status;
 138 }
 139
 140 static status_t generator_infos_write_chunk (generator_infos_t *this,chunk_t *data)
 141 {
 142         size_t data_length = this->out_position - this->buffer;
 143         if (this->current_bit > 0)
 144         data_length++;
 145         data->ptr = allocator_alloc(data_length);
 146         if (data->ptr == NULL)
 147         {
 148                 data->len = 0;
 149                 return OUT_OF_RES;
 150         }
 151         memcpy(data->ptr,this->buffer,data_length);
 152         data->len = data_length;
 153         return SUCCESS;
 154 }
 155
 156
 157 static status_t generator_infos_destroy (generator_infos_t *this)
 158 {
 159         if (this == NULL)
 160         {
 161                 return FAILED;
 162         }
 163         allocator_free(this->buffer);
 164         allocator_free(this);
 165         return SUCCESS;
 166 }
 167
 168 /**
 169  * Creates a generator_infos_t-object holding necessary informations
 170  * for generating (buffer, data_struct, etc)
 171  *
 172  * @param data_struct where to read the data out
 173  */
 174 generator_infos_t * generator_infos_create(void *data_struct)
 175 {
 176         generator_infos_t *this = allocator_alloc_thing(generator_infos_t);
 177
 178         if (this == NULL)
 179         {
 180                 return NULL;
 181         }
 182
 183         /* object methods */
 184         this->destroy = generator_infos_destroy;
 185         this->make_space_available = generator_info_make_space_available;
 186         this->write_chunk = generator_infos_write_chunk;
 187         this->write_bytes_to_buffer = generator_info_write_bytes_to_buffer;
 188
 189         /* allocate memory for buffer */
 190         this->buffer = allocator_alloc(GENERATOR_DATA_BUFFER_SIZE);
 191         if (this->buffer == NULL)
 192         {
 193                 allocator_free(this);
 194                 return NULL;
 195         }
 196
 197         /* set private data */
 198         this->out_position = this->buffer;
 199         this->roof_position = this->buffer + GENERATOR_DATA_BUFFER_SIZE;
 200         this->data_struct = data_struct;
 201         this->current_bit = 0;
 202         return (this);
 203 }
 204
 205
 206
 207 /**
 208  * Private data of a generator_t object
 209  */
 210 typedef struct private_generator_s private_generator_t;
 211
 212 struct private_generator_s {
 213         /**
 214          * Public part of a generator object
 215          */
 216          generator_t public;
 217
 218         /* private functions and fields */
 219
 220         /**
 221          * Generates a chunk_t with specific encoding rules
 222          *
 223          * items are bytewhise written
 224          *
 225          * @param this private_generator_t-object
 226          * @param data_struct data_struct to read data from
 227          * @param encoding_rules pointer to first encoding_rule of encoding rules array
 228          * @param encoding_rules_count number of encoding rules in encoding rules array
 229          * @param data pointer to chunk where to write the data in
 230          *
 231          * @return SUCCESS if succeeded,
 232          *                 OUT_OF_RES if out of ressources
 233          */
 234         status_t (*generate) (private_generator_t *this,void * data_struct,encoding_rule_t *encoding_rules, size_t encoding_rules_count, chunk_t *data);
 235
 236         /**
 237          * TODO
 238          */
 239         status_t (*generate_u_int_type) (private_generator_t *this,encoding_type_t int_type,u_int32_t offset, generator_infos_t *generator_infos);
 240
 241         /**
 242          * Pointer to the payload informations needed to automatic
 243          * generate a specific payload type
 244          */
 245         payload_info_t **payload_infos;
 246 };
 247
 248 /**
 249  * implements private_generator_t's double_buffer function
 250  */
 251 static status_t generate_u_int_type (private_generator_t *this,encoding_type_t int_type,u_int32_t offset,generator_infos_t *generator_infos)
 252 {
 253         size_t number_of_bits = 0;
 254         status_t status;
 255
 256
 257         switch (int_type)
 258         {
 259                         case U_INT_4:
 260                                 number_of_bits = 4;
 261                                 break;
 262                         case U_INT_8:
 263                                 number_of_bits = 8;
 264                                 break;
 265                         case U_INT_16:
 266                                 number_of_bits = 16;
 267                                 break;
 268                         case U_INT_32:
 269                                 number_of_bits = 32;
 270                                 break;
 271                         case U_INT_64:
 272                                 number_of_bits = 64;
 273                                 break;
 274                         default:
 275                         return FAILED;
 276         }
 277         if (((number_of_bits % 8) == 0) && (generator_infos->current_bit != 0))
 278         {
 279                 /* current bit has to be zero for values greater then 4 bits */
 280                 return FAILED;
 281         }
 282
 283         status = generator_infos->make_space_available(generator_infos,number_of_bits);
 284
 285         if (status != SUCCESS)
 286         {
 287                 return status;
 288         }
 289
 290         switch (int_type)
 291         {
 292                         case U_INT_4:
 293                         {
 294                                 if (generator_infos->current_bit == 0)
 295                                 {
 296                                         u_int8_t high_val = *((u_int8_t *)(generator_infos->data_struct + offset)) << 4;
 297                                         u_int8_t low_val = *(generator_infos->out_position) & 0x0F;
 298
 299                                         *(generator_infos->out_position) = high_val | low_val;
 300                                         /* write position is not changed, just bit position is moved */
 301                                         generator_infos->current_bit = 4;
 302                                 }
 303                                 else if (generator_infos->current_bit == 4)
 304                                 {
 305                                         u_int high_val = *(generator_infos->out_position) & 0xF0;
 306                                         u_int low_val = *((u_int8_t *)(generator_infos->data_struct + offset)) & 0x0F;
 307                                         *(generator_infos->out_position) = high_val | low_val;
 308                                         generator_infos->out_position++;
 309                                         generator_infos->current_bit = 0;
 310
 311                                 }
 312                                 else
 313                                 {
 314                                         /* 4 Bit integers must have a 4 bit alignment */
 315                                         return FAILED;
 316                                 };
 317                                 break;
 318                         }
 319
 320                         case U_INT_8:
 321                         {
 322                                 *generator_infos->out_position = *((u_int8_t *)(generator_infos->data_struct + offset));
 323                                 generator_infos->out_position++;
 324                                 break;
 325
 326                         }
 327                         case U_INT_16:
 328                         {
 329                                 u_int16_t int16_val = htons(*((u_int16_t*)(generator_infos->data_struct + offset)));
 330                                 generator_infos->write_bytes_to_buffer(generator_infos,&int16_val,sizeof(u_int16_t));
 331
 332                                 break;
 333                         }
 334                         case U_INT_32:
 335                         {
 336                                 u_int32_t int32_val = htonl(*((u_int32_t*)(generator_infos->data_struct + offset)));
 337                                 generator_infos->write_bytes_to_buffer(generator_infos,&int32_val,sizeof(u_int32_t));
 338                                 break;
 339                         }
 340                         case U_INT_64:
 341                         {
 342                                 u_int32_t int32_val_low = htonl(*((u_int32_t*)(generator_infos->data_struct + offset)));
 343                                 u_int32_t int32_val_high = htonl(*((u_int32_t*)(generator_infos->data_struct + offset) + 1));
 344                                 generator_infos->write_bytes_to_buffer(generator_infos,&int32_val_high,sizeof(u_int32_t));
 345                                 generator_infos->write_bytes_to_buffer(generator_infos,&int32_val_low,sizeof(u_int32_t));
 346                                 break;
 347                         }
 348
 349                         default:
 350                         return FAILED;
 351
 352         }
 353
 354         return SUCCESS;
 355 }
 356
 357 /**
 358  * implements private_generator_t's generate function
 359  */
 360 static status_t generate (private_generator_t *this,void * data_struct,encoding_rule_t *encoding_rules, size_t encoding_rules_count, chunk_t *data)
 361 {
 362         int i;
 363         status_t status;
 364
 365
 366         generator_infos_t *infos = generator_infos_create(data_struct);
 367
 368         if (infos == NULL)
 369         {
 370                 return OUT_OF_RES;
 371         }
 372
 373
 374         for (i = 0; i < encoding_rules_count;i++)
 375         {
 376                 status = SUCCESS;
 377                 switch (encoding_rules[i].type)
 378                 {
 379                         /* all u int values are generated in generate_u_int_type */
 380                         case U_INT_4:
 381                         case U_INT_8:
 382                         case U_INT_16:
 383                         case U_INT_32:
 384                         case U_INT_64:
 385                                 status = this->generate_u_int_type(this,encoding_rules[i].type,encoding_rules[i].offset,infos);
 386                                 break;
 387                         case RESERVED_BIT:
 388                         {
 389                                 u_int8_t reserved_bit = ~(1 << (7 - infos->current_bit));
 390
 391                                 *(infos->out_position) = *(infos->out_position) & reserved_bit;
 392
 393                                 infos->current_bit++;
 394                                 if (infos->current_bit >= 8)
 395                                 {
 396                                         infos->current_bit = infos->current_bit % 8;
 397                                         status = infos->make_space_available(infos,8);
 398                                         infos->out_position++;
 399                                 }
 400                                 break;
 401                         }
 402                         case RESERVED_BYTE:
 403                         {
 404                                 if (infos->current_bit > 0)
 405                                 {
 406                                         return FAILED;
 407                                 }
 408                                 *(infos->out_position) = 0x00;
 409                                 infos->out_position++;
 410                                 break;
 411                         }
 412                         case FLAG:
 413                         {
 414                                 u_int8_t flag_value = (*((bool *) (infos->data_struct + encoding_rules[i].offset))) ? 1 : 0;
 415                                 u_int8_t flag = (flag_value << (7 - infos->current_bit));
 416
 417                                 *(infos->out_position) = *(infos->out_position) | flag;
 418
 419                                 infos->current_bit++;
 420                                 if (infos->current_bit >= 8)
 421                                 {
 422                                         infos->current_bit = infos->current_bit % 8;
 423                                         status = infos->make_space_available(infos,8);
 424                                         infos->out_position++;
 425                                 }
 426                                 break;
 427                         }
 428                         case LENGTH:
 429                                 /* length is generated like an U_INT_32 */
 430                                 status = this->generate_u_int_type(this,U_INT_32,encoding_rules[i].offset,infos);
 431                         case SPI_SIZE:
 432                                 /* actually not implemented */
 433                         default:
 434                                 break;
 435                 }
 436                 if (status != SUCCESS)
 437                 {
 438                         infos->destroy(infos);
 439                         return status;
 440                 }
 441         }
 442
 443
 444         status = infos->write_chunk(infos,data);
 445         infos->destroy(infos);
 446         return status;
 447 }
 448
 449 static status_t generate_payload (private_generator_t *this,payload_type_t payload_type,void * data_struct, chunk_t *data)
 450 {
 451         int i;
 452
 453         /* check every payload info for specific type */
 454         for (i = 0; this->payload_infos[i] != NULL; i++)
 455         {
 456                 if (this->payload_infos[i]->payload_type == payload_type)
 457                 {
 458                         /* found payload informations, generating is done in private function generate() */
 459                         return (this->generate(this, data_struct,this->payload_infos[i]->ecoding_rules,this->payload_infos[i]->encoding_rules_count,data));
 460                 }
 461         }
 462         return NOT_SUPPORTED;
 463 }
 464
 465 /**
 466  * Implementation of generator_t's destroy function
 467  */
 468 static status_t destroy(private_generator_t *this)
 469 {
 470         if (this == NULL)
 471         {
 472                 return FAILED;
 473         }
 474
 475         allocator_free(this);
 476         return SUCCESS;
 477 }
 478
 479 /*
 480  * Described in header
 481  */
 482 generator_t * generator_create(payload_info_t ** payload_infos)
 483 {
 484         private_generator_t *this;
 485
 486         if (payload_infos == NULL)
 487         {
 488                 return NULL;
 489         }
 490
 491         this = allocator_alloc_thing(private_generator_t);
 492         if (this == NULL)
 493         {
 494                 return NULL;
 495         }
 496
 497         /* initiate public functions */
 498         this->public.generate_payload = (status_t(*)(generator_t*, payload_type_t, void *, chunk_t *)) generate_payload;
 499         this->public.destroy = (status_t(*)(generator_t*)) destroy;
 500
 501         /* initiate private functions */
 502         this->generate = generate;
 503         this->generate_u_int_type = generate_u_int_type;
 504
 505         /* initiate private variables */
 506         this->payload_infos = payload_infos;
 507
 508         return &(this->public);
 509 }