modules/ud/ud_misc.c

/* [<][>]
[^][v][top][bottom][index][help] */

FUNCTIONS

This source file includes following functions.
  1. attribute_free
  2. attribute_upd
  3. attribute_new1
  4. attribute_new
  5. object_free
  6. object_new
  7. transaction_free
  8. transaction_new

   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)
     /* [<][>][^][v][top][bottom][index][help] */
  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)
     /* [<][>][^][v][top][bottom][index][help] */
  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) 
     /* [<][>][^][v][top][bottom][index][help] */
  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) {
     /* [<][>][^][v][top][bottom][index][help] */
  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) {
     /* [<][>][^][v][top][bottom][index][help] */
 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) {
     /* [<][>][^][v][top][bottom][index][help] */
 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) {
     /* [<][>][^][v][top][bottom][index][help] */
 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) {
     /* [<][>][^][v][top][bottom][index][help] */
 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() */

/* [<][>][^][v][top][bottom][index][help] */