unirec.h

Go to the documentation of this file.

/*
 * Copyright (C) 2015 CESNET

 *
 * LICENSE TERMS
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of the Company nor the names of its contributors
 *    may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * ALTERNATIVELY, provided that this notice is retained in full, this
 * product may be distributed under the terms of the GNU General Public
 * License (GPL) version 2 or later, in which case the provisions
 * of the GPL apply INSTEAD OF those given above.
 *
 * This software is provided ``as is'', and any express or implied
 * warranties, including, but not limited to, the implied warranties of
 * merchantability and fitness for a particular purpose are disclaimed.
 * In no event shall the company or contributors be liable for any
 * direct, indirect, incidental, special, exemplary, or consequential
 * damages (including, but not limited to, procurement of substitute
 * goods or services; loss of use, data, or profits; or business
 * interruption) however caused and on any theory of liability, whether
 * in contract, strict liability, or tort (including negligence or
 * otherwise) arising in any way out of the use of this software, even
 * if advised of the possibility of such damage.
 *
 */

#ifndef _UNIREC2_H_
#define _UNIREC2_H_

#ifdef __cplusplus
extern "C" {
#endif

#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#endif
#include <stdint.h>

#include "ipaddr.h"
#include "macaddr.h"
#include "ur_time.h"
#include "links.h"
#include "ur_values.h"
#include <libtrap/trap.h>

//General setting
#define UR_DEFAULT_LENGTH_OF_TEMPLATE 1024 
#define UR_DEFAULT_LENGTH_OF_FIELD_NAME 128 
#define UR_DEFAULT_LENGTH_OF_FIELD_TYPE 16 
#define UR_INITIAL_SIZE_FIELDS_TABLE 5 
#define UR_FIELD_ID_MAX INT16_MAX       
#define UR_FIELDS(...)        
#define UR_ARRAY_DELIMITER ' ' 
#define UR_ARRAY_ALLOC 10 
//Iteration constants
#define UR_ITER_BEGIN (-1)  
#define UR_ITER_END INT16_MAX    
//default values
#define UR_INVALID_OFFSET 0xffff 
#define UR_NO_DYNAMIC_VALUES 0xffff    
#define UR_UNINITIALIZED 0          
#define UR_INITIALIZED 1            
#define UR_INVALID_FIELD ((ur_field_id_t) 0xffff)    
//return codes
#define UR_E_INVALID_PARAMETER -6   
#define UR_E_INVALID_FIELD_ID -5       
#define UR_E_TYPE_MISMATCH -4    
#define UR_E_INVALID_NAME -3     
#define UR_E_INVALID_TYPE -2     
#define UR_E_MEMORY -1        
#define UR_OK 0         


#define UR_COUNT_OF_TYPES 29 
typedef enum {
   UR_TYPE_STRING,   
   UR_TYPE_BYTES,    
   UR_TYPE_CHAR,  
   UR_TYPE_UINT8, 
   UR_TYPE_INT8,  
   UR_TYPE_UINT16,   
   UR_TYPE_INT16, 
   UR_TYPE_UINT32,   
   UR_TYPE_INT32, 
   UR_TYPE_UINT64,   
   UR_TYPE_INT64, 
   UR_TYPE_FLOAT, 
   UR_TYPE_DOUBLE,   
   UR_TYPE_IP,    
   UR_TYPE_MAC,    
   UR_TYPE_TIME,   

   // Arrays
   UR_TYPE_A_UINT8, 
   UR_TYPE_A_INT8,  
   UR_TYPE_A_UINT16,   
   UR_TYPE_A_INT16, 
   UR_TYPE_A_UINT32,   
   UR_TYPE_A_INT32, 
   UR_TYPE_A_UINT64,   
   UR_TYPE_A_INT64, 
   UR_TYPE_A_FLOAT, 
   UR_TYPE_A_DOUBLE,   
   UR_TYPE_A_IP,    
   UR_TYPE_A_MAC,    
   UR_TYPE_A_TIME   
} ur_field_type_t;

typedef enum {
   UR_TMPLT_DIRECTION_NO,  
   UR_TMPLT_DIRECTION_IN,  
   UR_TMPLT_DIRECTION_OUT, 
   UR_TMPLT_DIRECTION_BI   
} ur_tmplt_direction;

typedef int16_t ur_field_id_t;  
typedef ur_field_id_t ur_iter_t; 

typedef struct ur_field_id_linked_list_s ur_field_id_linked_list_t;
struct ur_field_id_linked_list_s{
  ur_field_id_t id;        
  ur_field_id_linked_list_t *next;  
};

typedef struct {
   char **ur_field_names;     
   short *ur_field_sizes;     
   ur_field_type_t *ur_field_types;    
   ur_field_id_t ur_last_id;     
} ur_static_field_specs_t;

typedef struct {
   char **ur_field_names;        
   short *ur_field_sizes;        
   ur_field_type_t *ur_field_types;    
   ur_field_id_t ur_last_statically_defined_id; 
   ur_field_id_t ur_last_id;        

   ur_field_id_t ur_allocated_fields;
   ur_field_id_linked_list_t * ur_undefine_fields; 
   uint8_t intialized;  
} ur_field_specs_t;

typedef struct field_spec_s {
   char *name;    
   int size;      
   ur_field_id_t id; 
} field_spec_t;

typedef struct {
   uint16_t *offset;       
   uint16_t offset_size;   
   int16_t *ids;    
   uint16_t first_dynamic; 
   uint16_t count;      
   uint16_t static_size;   
   ur_tmplt_direction direction; 
   uint32_t ifc_out;   
} ur_template_t;

#define TRAP_RECEIVE(ifc_num, data, data_size, tmplt) \
 TRAP_CTX_RECEIVE(trap_get_global_ctx(), ifc_num, data, data_size, tmplt);

#define TRAP_CTX_RECEIVE(ctx, ifc_num, data, data_size, tmplt) __extension__ \
({\
   int ret = trap_ctx_recv(ctx, ifc_num, &data, &data_size);\
   if (ret == TRAP_E_FORMAT_CHANGED) {\
      const char *spec = NULL;\
      uint8_t data_fmt;\
      if (trap_ctx_get_data_fmt(ctx, TRAPIFC_INPUT, ifc_num, &data_fmt, &spec) != TRAP_E_OK) {\
         fprintf(stderr, "Data format was not loaded.\n");\
      } else {\
         tmplt = ur_define_fields_and_update_template(spec, tmplt);\
         if (tmplt == NULL) {\
            fprintf(stderr, "Template could not be edited.\n");\
         } else {\
            if (tmplt->direction == UR_TMPLT_DIRECTION_BI) {\
               char * spec_cpy = ur_cpy_string(spec);\
               if (spec_cpy == NULL) {\
                  fprintf(stderr, "Memory allocation problem.\n");\
               } else {\
                  trap_ctx_set_data_fmt(ctx, tmplt->ifc_out, TRAP_FMT_UNIREC, spec_cpy);\
               }\
            }\
         }\
      }\
   }\
   ret;\
})

/*#define UNIREC_CTX_CHECK_TEMPLATE (ctx, ret, ifc_num, tmplt, fmt_changed_cmd, fmt_not_compatabile_cmd) __extension__ \
({\
   if (ret == TRAP_E_OK_FORMAT_CHANGED && trap_ctx_get_in_ifc_state(ctx, ifc_num) == FMT_SUBSET) {\
      const char *spec = NULL;\
      uint8_t data_fmt;\
      if (trap_ctx_get_data_fmt(ctx, TRAPIFC_INPUT, ifc_num, &data_fmt, &spec) != TRAP_E_OK) {\
         fprintf(stderr, "Data format was not loaded.");\
      } else {\
         tmplt = ur_define_fields_and_update_template(spec, tmplt);\
         if (tmplt == NULL) {\
            fprintf(stderr, "Template could not be edited");\
         } else {\
            if (tmplt->direction == UR_TMPLT_DIRECTION_BI) {\
               char * spec_cpy = ur_cpy_string(spec);\
               if (spec_cpy == NULL) {\
                  fprintf(stderr, "Memory allocation problem.");\
               } else {\
                  trap_ctx_set_data_fmt(ctx, tmplt->ifc_out, TRAP_FMT_UNIREC, spec_cpy);\
               }\
            }\
            trap_ctx_confirm_ifc_state(ctx, ifc_num);\
            fmt_changed_cmd;
         }\
      }\
   }\
   ret;\
})*/
/* libtraphelpers */

extern const int ur_field_type_size[];

extern const char *ur_field_type_str[];

extern int ur_field_array_elem_type[];

extern ur_field_specs_t ur_field_specs;

extern ur_static_field_specs_t UR_FIELD_SPECS_STATIC;

char *ur_template_string_delimiter(const ur_template_t *tmplt, int delimiter);

#define ur_template_string(tmplt) \
 ur_template_string_delimiter(tmplt, ',')

#define ur_size_of(type) \
   ur_field_type_size[type]

#define ur_get_name(field_id) \
   ur_field_specs.ur_field_names[field_id]

#define ur_get_type(field_id) \
   ur_field_specs.ur_field_types[field_id]

int ur_get_field_type_from_str(const char *type);

#define ur_get_size(field_id) \
   ur_field_specs.ur_field_sizes[field_id]

#define ur_get(tmplt, data, field_id) \
   (*(field_id ## _T*)((char *)(data) + (tmplt)->offset[field_id]))

#define ur_get_ptr(tmplt, data, field_id) \
   (field_id ## _T*)((char *) (ur_is_static(field_id) ? ((char *)(data) + (tmplt)->offset[field_id]) : \
   (char *)(data) + (tmplt)->static_size + (*((uint16_t *)((char *)(data) + (tmplt)->offset[field_id])))))

#define ur_get_ptr_by_id(tmplt, data, field_id) \
   (void *)((char *) (ur_is_static(field_id) ? ((char *)(data) + (tmplt)->offset[field_id]) : \
      (char *)(data) + (tmplt)->static_size + (*((uint16_t *)((char *)(data) + (tmplt)->offset[field_id])))))

#define ur_set(tmplt, data, field_id, value) \
   (*(field_id ## _T*)((char *)(data) + (tmplt)->offset[field_id]) = (value))

#define ur_get_var_offset(tmplt, rec, field_id) \
   *((uint16_t *)((char *) rec + tmplt->offset[field_id]))

#define ur_get_var_len(tmplt, rec, field_id) \
   *((uint16_t *)((char *) rec + tmplt->offset[field_id] + 2))

#define ur_set_var_len(tmplt, rec, field_id, len) \
   *((uint16_t *)((char *) rec + tmplt->offset[field_id] + 2)) = (uint16_t) len

#define ur_set_var_offset(tmplt, rec, field_id, offset_val) \
   *((uint16_t *)((char *) rec + tmplt->offset[field_id])) = (uint16_t) offset_val

#define ur_get_len(tmplt, rec, field) \
   ur_is_static(field) ? ur_get_size(field) : ur_get_var_len(tmplt, rec, field)

#define ur_set_string(tmplt, rec, field_id, str) \
   ur_set_var(tmplt, rec, field_id, str, strlen(str))

#define ur_is_array(field_id) \
   (ur_field_type_size[ur_get_type(field_id)] < 0 ? 1 : 0)

#define ur_array_get_elem_size(field_id) \
   (ur_field_type_size[ur_get_type(field_id)] < 0 ? -ur_field_type_size[ur_get_type(field_id)] : ur_field_type_size[ur_get_type(field_id)])

#define ur_array_get_elem_cnt(tmplt, rec, field_id) \
   (ur_get_var_len(tmplt, rec, field_id) / ur_array_get_elem_size(field_id))

#define ur_array_get_elem_type(field_id) \
   ur_field_array_elem_type[ur_get_type(field_id)]

#define ur_array_set(tmplt, rec, field_id, index, element) \
   if ((index) * ur_array_get_elem_size(field_id) < ur_get_var_len(tmplt, rec, field_id) || ur_array_resize(tmplt, rec, field_id, (index + 1) * ur_array_get_elem_size(field_id)) == UR_OK) { \
      (((field_id ## _T)((char *)(ur_get_ptr_by_id(tmplt, rec, field_id))))[index] = (element)); \
   }

#define ur_array_append(tmplt, rec, field_id, element) \
   if (ur_array_resize(tmplt, rec, field_id, (ur_array_get_elem_cnt(tmplt, rec, field_id) + 1) * ur_array_get_elem_size(field_id)) == UR_OK) { \
      (((field_id ## _T)((char *)(ur_get_ptr_by_id(tmplt, rec, field_id))))[ur_array_get_elem_cnt(tmplt, rec, field_id) - 1] = (element)); \
   }

char *ur_array_append_get_ptr(const ur_template_t *tmplt, void *rec, int field_id);

#define ur_array_clear(tmplt, rec, field_id) \
   ur_array_resize(tmplt, rec, field_id, 0)

#define ur_array_get(tmplt, rec, field_id, index) \
   ((field_id ## _T)((char *)(ur_get_ptr_by_id(tmplt, rec, field_id))))[index]

#define ur_array_allocate(tmplt, rec, field_id, elem_cnt) \
   ur_array_resize(tmplt, rec, field_id, (elem_cnt) * ur_array_get_elem_size(field_id))

#define ur_is_present(tmplt, field_id) \
   ((tmplt)->offset_size > (field_id) && (tmplt)->offset[(field_id)] != UR_INVALID_OFFSET)

#define ur_is_varlen(field_id) \
   (ur_field_specs.ur_field_sizes[field_id] < 0)

#define ur_is_dynamic(field_id) \
   ur_is_varlen(field_id)

#define ur_is_fixlen(field_id) \
   (ur_field_specs.ur_field_sizes[field_id] >= 0)

#define ur_is_static(field_id) \
   ur_is_fixlen(field_id)


#define ur_rec_fixlen_size(tmplt) \
   ((tmplt)->static_size)

#define ur_rec_size(tmplt, rec) \
   (ur_rec_fixlen_size(tmplt) + ur_rec_varlen_size(tmplt, rec))

int ur_init(ur_static_field_specs_t field_specs_static);

int ur_get_empty_id();

int ur_define_field(const char *name, ur_field_type_t type);

int ur_define_set_of_fields(const char *ifc_data_fmt);

int ur_undefine_field_by_id(ur_field_id_t field_id);

int ur_undefine_field(const char *name);

void ur_finalize();

int ur_get_id_by_name(const char *name);

int compare_fields(const void *field1, const void *field2);

ur_template_t *ur_create_template(const char *fields, char **errstr);

#define ur_create_input_template(ifc, fields, errstr) \
   ur_ctx_create_input_template(trap_get_global_ctx(), ifc, fields, errstr);

#define ur_create_output_template(ifc, fields, errstr) \
   ur_ctx_create_output_template(trap_get_global_ctx(), ifc, fields, errstr);

ur_template_t *ur_ctx_create_output_template(trap_ctx_t *ctx, int ifc, const char *fields, char **errstr);

ur_template_t *ur_ctx_create_input_template(trap_ctx_t *ctx, int ifc, const char *fields, char **errstr);


int ur_ctx_set_output_template(trap_ctx_t *ctx, int ifc, ur_template_t *tmplt);

#define  ur_set_output_template(ifc, tmplt) \
   ur_ctx_set_output_template(trap_get_global_ctx(), ifc, tmplt)

int ur_ctx_set_input_template(trap_ctx_t *ctx, int ifc, ur_template_t *tmplt);

#define  ur_set_input_template(ifc, tmplt) \
   ur_ctx_set_input_template(trap_get_global_ctx(), ifc, tmplt)

ur_template_t *ur_ctx_create_bidirectional_template(trap_ctx_t *ctx, int ifc_in, int ifc_out, const char *fields, char **errstr);

#define ur_create_bidirectional_template(ifc_in, ifc_out, fields, errstr) \
   ur_ctx_create_bidirectional_template(trap_get_global_ctx(), ifc_in, ifc_out, fields, errstr);

ur_template_t *ur_expand_template(const char *ifc_data_fmt, ur_template_t *tmplt);

ur_template_t *ur_define_fields_and_update_template(const char *ifc_data_fmt, ur_template_t *tmplt);

ur_template_t *ur_create_template_from_ifc_spec(const char *ifc_data_fmt);

void ur_free_template(ur_template_t *tmplt);

int ur_template_compare(const ur_template_t *tmpltA, const ur_template_t *tmpltB);


void ur_print_template(ur_template_t *tmplt);

int ur_set_var(const ur_template_t *tmplt, void *rec, int field_id, const void *val_ptr, int val_len);

int ur_array_resize(const ur_template_t *tmplt, void *rec, int field_id, int len);

void ur_clear_varlen(const ur_template_t *tmplt, void *rec);

uint16_t ur_rec_varlen_size(const ur_template_t *tmplt, const void *rec);

void *ur_create_record(const ur_template_t *tmplt, uint16_t max_var_size);
#define UR_MAX_SIZE 0xffff

void ur_free_record(void *record);

char *ur_get_var_as_str(const ur_template_t *tmplt, const void *rec, ur_field_id_t field_id);

void ur_copy_fields(const ur_template_t *dst_tmplt, void *dst, const ur_template_t *src_tmplt, const void *src);

#define ur_cpy(tmplt, src, dst) \
    (memcpy(dst,src,ur_rec_size(tmplt,src)))
/*inline void ur_cpy(ur_template_t *tmplt, const void *src, void *dst)
{
    memcpy(dst, src, ur_rec_size(tmplt, src));
}*/

void *ur_clone_record(const ur_template_t *tmplt, const void *src);

ur_iter_t ur_iter_fields(const ur_template_t *tmplt, ur_iter_t id);

ur_iter_t ur_iter_fields_record_order(const ur_template_t *tmplt, int index);

int ur_set_array_from_string(const ur_template_t *tmpl, void *data, ur_field_id_t f_id, const char *v);

int ur_set_from_string(const ur_template_t *tmpl, void *data, ur_field_id_t f_id, const char *v);

char *ur_ifc_data_fmt_to_field_names(const char *ifc_data_fmt);

char *ur_cpy_string(const char *str);

const char *ur_values_get_name_start_end(uint32_t start, uint32_t end, int32_t value);

const char *ur_values_get_description_start_end(uint32_t start, uint32_t end, int32_t value);

#define ur_values_get_name(field, value) \
   ur_values_get_name_start_end(UR_TYPE_START_ ## field, UR_TYPE_END_ ## field, value)

#define ur_values_get_description(field, value) \
   ur_values_get_description_start_end(UR_TYPE_START_ ## field, UR_TYPE_END_ ## field, value)
/* urtemplate */

#ifdef __cplusplus
} // extern "C"
#endif

#endif