Source File modules/ud/ud_misc.c

    1    | /***************************************
    2    |   $Revision: 1.11 $
    3    |
    4    |   Miscellaneous functions to support UD
    5    |
    6    |   Status: NOT REVUED, NOT TESTED
    7    |
    8    |  Author(s):       Chris Ottrey, Andrei Robachevsky
    9    |
    10   |   ******************/ /******************
    11   |   Modification History:
    12   |         andrei (17/01/2000) Created.
    13   |   ******************/ /******************
    14   |   Copyright (c) 2000                              RIPE NCC
    15   |
    16   |   All Rights Reserved
    17   |
    18   |   Permission to use, copy, modify, and distribute this software and its
    19   |   documentation for any purpose and without fee is hereby granted,
    20   |   provided that the above copyright notice appear in all copies and that
    21   |   both that copyright notice and this permission notice appear in
    22   |   supporting documentation, and that the name of the author not be
    23   |   used in advertising or publicity pertaining to distribution of the
    24   |   software without specific, written prior permission.
    25   |
    26   |   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
    27   |   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
    28   |   AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
    29   |   DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
    30   |   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    31   |   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
    32   |  ***************************************/
    33   | #include "ud.h"
    34   | #include "ud_int.h"
    35   | /************************************************************
    36   | * void attribute_free()                                     *
    37   | *                                                           *
    38   | * Frees memory allocated for an attribute                   *
    39   | *                                                           *
    40   | ************************************************************/
    41   | void attribute_free(void *data, void *ptr)
    42   | {
    43   | Attribute_t *attr = data;
    44   |
    45   | 	free(attr->value);
    46   | 	free(attr);
    47   | }
    48   |
    49   | /************************************************************
    50   | * Attribute_t *attribute_upd()                              *
    51   | *                                                           *
    52   | * Changes the value of an attribute                         *
    53   | *                                                           *
    54   | ************************************************************/
    55   | Attribute_t *attribute_upd(Attribute_t *attr, int newtype, char *newvalue)
    56   | {
    57   |  attr->type=newtype;
    58   |  free(attr->value);
    59   |  attr->value=g_strdup(newvalue);
    60   |  return(attr);
    61   | }
    62   |
    63   | /************************************************************
    64   | * Attribute_t *attribute_new1()                             *
    65   | *                                                           *
    66   | * Creates an attribute and fills the type and value         *
    67   | *                                                           *
    68   | ************************************************************/
    69   | Attribute_t *attribute_new1(int type, const char *value)
    70   | {
    71   | char *n;
    72   | Attribute_t *attr = NULL;
    73   |
    74   |       attr = (Attribute_t *)calloc(1, sizeof(Attribute_t)+1);
    75   |       attr->type = type;
    76   |
    77   |       /* check for end-of-line comments */
    78   |       n = index(value, '#');
    79   |       /* if there is no comment check for trailing \n */
    80   |       if(n == NULL) n = index(value, '\n');
    81   |       /* now copy the clean value into the attribute */
    82   |       if(n == NULL) attr->value = g_strdup(value);
    83   |       else  attr->value = g_strndup(value, (n - value));
    84   |       /* Strip the whitespace */
    85   |       g_strstrip(attr->value);
    86   |       return(attr);
    87   |
    88   | }
    89   | /************************************************************
    90   | * Attribute_t *attribute_new()                              *
    91   | *                                                           *
    92   | * Determines the type and value of an attribute and         *
    93   | * creates it by calling attribute_new1()                    *
    94   | *                                                           *
    95   | ************************************************************/
    96   | Attribute_t *attribute_new(const char *line) {
    97   |   Attribute_t *attr = NULL;
    98   |   int type;
    99   |   char *colon;
    100  |   gchar *token;
    101  |
    102  |
    103  |   colon = index(line, ':');
    104  |   if (colon != NULL) {
    105  |     if (line[0] =='*') {
    106  |       token = g_strndup(line+1, 2);
    107  |       type = DF_attribute_code2type(token);
    108  |     }
    109  |     else {
    110  |       token = g_strndup(line, (colon - line));
    111  |       type = DF_attribute_name2type(token);
    112  |     }
    113  |     if(token)free(token);
    114  |
    115  |     colon+=2;
    116  |     if (type >= 0) {
    117  | 	attr=attribute_new1(type, colon);
    118  |     }
    119  |   }
    120  |   return attr;
    121  | } /* attribute_new() */
    122  |
    123  | /************************************************************
    124  | * void object_free()                                        *
    125  | *                                                           *
    126  | * Frees memory allocated for an object                      *
    127  | *                                                           *
    128  | ************************************************************/
    129  | void object_free(Object_t *obj) {
    130  |   if (obj) {
    131  |    g_slist_foreach(obj->attributes, attribute_free, NULL);
    132  |    g_slist_free(obj->attributes);
    133  |    g_string_free(obj->object, TRUE);
    134  |    free(obj);
    135  |   }
    136  | } /* object_free() */
    137  |
    138  | /************************************************************
    139  | * Object_t *object_new()                                    *
    140  | *                                                           *
    141  | * Determines the class type and creates an object           *
    142  | *                                                           *
    143  | ************************************************************/
    144  | Object_t *object_new(const char *line) {
    145  |   Object_t *obj = NULL;
    146  |
    147  |   int type;
    148  |   char *colon;
    149  |   gchar *token=NULL;
    150  |
    151  |   colon = index(line, ':');
    152  |   if (colon != NULL) {
    153  |     if (line[0] =='*') {
    154  |       token = g_strndup(line+1, 2);
    155  |       type = DF_class_code2type(token);
    156  |     }
    157  |     else {
    158  |       token = g_strndup(line, (colon - line));
    159  |       type = DF_class_name2type(token);
    160  |     }
    161  |     if(token)free(token);
    162  |
    163  |     if (type >= 0) {
    164  |       obj = (Object_t *)calloc(1, sizeof(Object_t)+1);
    165  |       obj->attributes = NULL;
    166  |       obj->object = g_string_sized_new(STR_XXXL);
    167  |       obj->type = type;
    168  |     }
    169  |   }
    170  |   return obj;
    171  | } /* object_new() */
    172  |
    173  |
    174  | /************************************************************
    175  | * void transaction_free()                                   *
    176  | *                                                           *
    177  | * Frees memory allocated for a transaction                  *
    178  | *                                                           *
    179  | ************************************************************/
    180  |
    181  | void transaction_free(Transaction_t *tr) {
    182  |   if(tr) {
    183  |     g_string_free(tr->error_script, TRUE);
    184  |     /* free nic_handle_t structure used for NHR stuff */
    185  |     if(tr->nh)free_nh(tr->nh);
    186  |     if(tr->save)free(tr->save);
    187  |     if(tr->packptr)free(tr->packptr);
    188  |     free(tr);
    189  |   }
    190  | } /* transaction_free() */
    191  |
    192  | /************************************************************
    193  | * Transaction_t *transaction_new()                          *
    194  | *                                                           *
    195  | * Creates a transaction                                     *
    196  | *                                                           *
    197  | ************************************************************/
    198  | Transaction_t *transaction_new(SQ_connection_t *sql_connection, C_Type_t class_type) {
    199  |   Transaction_t *tr = (Transaction_t *)calloc(1, sizeof(Transaction_t));
    200  |
    201  |   if (tr != NULL) {
    202  |     tr->sql_connection = sql_connection;
    203  |     tr->class_type = class_type;
    204  |     tr->thread_upd=TR_UPDATE;
    205  |     tr->thread_ins=TR_INSERT;
    206  |     tr->object_id = 0; /* Just in case*/
    207  |     tr->succeeded = 1;
    208  |     tr->error=0;
    209  |     tr->error_script = g_string_sized_new(STR_XL);
    210  |     tr->dummy = 0; /* By default do not create dummies except for sets*/
    211  |     tr->ndummy=0;
    212  |     tr->action=100;
    213  |     tr->load_pass=0; /* by default*/
    214  |     tr->sequence_id=1; /* we start from 1*/
    215  |     tr->save=NULL;
    216  |     tr->nh=NULL;
    217  |     tr->packptr=calloc(1, sizeof(rp_upd_pack_t));
    218  |
    219  |   }
    220  |   return tr;
    221  | } /* transaction_new() */