source/lib/util_array.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Samba utility functions
   5    Copyright (C) Andrew Tridgell              1992-1999
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-1999
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 void free_void_array(uint32 num_entries, void **entries,
  26                 void(free_item)(void*))
  27 {
  28         uint32 i;
  29         if (entries != NULL)
  30         {
  31                 for (i = 0; i < num_entries; i++)
  32                 {
  33                         if (entries[i] != NULL)
  34                         {
  35                                 free_item(entries[i]);
  36                         }
  37                 }
  38                 free(entries);
  39         }
  40 }
  41
  42 void* add_copy_to_array(uint32 *len, void ***array, const void *item,
  43         void*(item_dup)(const void*), BOOL alloc_anyway)
  44 {
  45         void* copy = NULL;
  46         if (len == NULL || array == NULL)
  47         {
  48                 return NULL;
  49         }
  50
  51         if (item != NULL || alloc_anyway)
  52         {
  53                 copy = item_dup(item);
  54                 return add_item_to_array(len, array, copy);
  55         }
  56         return copy;
  57 }
  58
  59 void* add_item_to_array(uint32 *len, void ***array, void *item)
  60 {
  61         void **tary;
  62
  63         if (len == NULL || array == NULL)
  64                 return NULL;
  65
  66         tary = (void**)Realloc((*array), ((*len)+1)*sizeof((*array)[0]));
  67
  68         if (tary != NULL) {
  69                 (*array) = tary;
  70                 (*array)[(*len)] = item;
  71                 (*len)++;
  72                 return item;
  73         } else {
  74                 free((char *)*array);
  75         }
  76         return NULL;
  77 }
  78
  79 static void use_info_free(struct use_info *item)
  80 {
  81         if (item != NULL)
  82         {
  83                 if (item->srv_name != NULL)
  84                 {
  85                         free(item->srv_name);
  86                 }
  87                 if (item->user_name != NULL)
  88                 {
  89                         free(item->user_name);
  90                 }
  91                 if (item->domain != NULL)
  92                 {
  93                         free(item->domain);
  94                 }
  95                 free(item);
  96         }
  97 }
  98
  99 static struct use_info *use_info_dup(const struct use_info *from)
 100 {
 101         if (from != NULL)
 102         {
 103                 struct use_info *copy = (struct use_info *)
 104                                         malloc(sizeof(struct use_info));
 105                 if (copy != NULL)
 106                 {
 107                         ZERO_STRUCTP(copy);
 108                         copy->connected = from->connected;
 109                         if (from->srv_name != NULL)
 110                         {
 111                                 copy->srv_name  = strdup(from->srv_name );
 112                         }
 113                         if (from->user_name != NULL)
 114                         {
 115                                 copy->user_name = strdup(from->user_name);
 116                         }
 117                         if (from->domain != NULL)
 118                         {
 119                                 copy->domain    = strdup(from->domain   );
 120                         }
 121                 }
 122                 return copy;
 123         }
 124         return NULL;
 125 }
 126
 127 void free_use_info_array(uint32 num_entries, struct use_info **entries)
 128 {
 129         void(*fn)(void*) = (void(*)(void*))&use_info_free;
 130         free_void_array(num_entries, (void**)entries, *fn);
 131 }
 132
 133 struct use_info* add_use_info_to_array(uint32 *len, struct use_info ***array,
 134                                 const struct use_info *name)
 135 {
 136         void*(*fn)(const void*) = (void*(*)(const void*))&use_info_dup;
 137         return (struct use_info*)add_copy_to_array(len,
 138                              (void***)array, (const void*)name, *fn, False);
 139
 140 }
 141
 142 void free_char_array(uint32 num_entries, char **entries)
 143 {
 144         void(*fn)(void*) = (void(*)(void*))&free;
 145         free_void_array(num_entries, (void**)entries, *fn);
 146 }
 147
 148 char* add_chars_to_array(uint32 *len, char ***array, const char *name)
 149 {
 150         void*(*fn)(const void*) = (void*(*)(const void*))&strdup;
 151         return (char*)add_copy_to_array(len,
 152                              (void***)array, (const void*)name, *fn, False);
 153
 154 }
 155
 156 static uint32 *uint32_dup(const uint32* from)
 157 {
 158         if (from != NULL)
 159         {
 160                 uint32 *copy = (uint32 *)malloc(sizeof(uint32));
 161                 if (copy != NULL)
 162                 {
 163                         memcpy(copy, from, sizeof(*copy));
 164                 }
 165                 return copy;
 166         }
 167         return NULL;
 168 }
 169
 170 void free_uint32_array(uint32 num_entries, uint32 **entries)
 171 {
 172         void(*fn)(void*) = (void(*)(void*))&free;
 173         free_void_array(num_entries, (void**)entries, *fn);
 174 }
 175
 176 uint32* add_uint32s_to_array(uint32 *len, uint32 ***array, const uint32 *name)
 177 {
 178         void*(*fn)(const void*) = (void*(*)(const void*))&uint32_dup;
 179         return (uint32*)add_copy_to_array(len,
 180                              (void***)array, (const void*)name, *fn, False);
 181
 182 }
 183
 184 void free_sid_array(uint32 num_entries, DOM_SID **entries)
 185 {
 186         void(*fn)(void*) = (void(*)(void*))&free;
 187         free_void_array(num_entries, (void**)entries, *fn);
 188 }
 189
 190 DOM_SID* add_sid_to_array(uint32 *len, DOM_SID ***array, const DOM_SID *sid)
 191 {
 192         void*(*fn)(const void*) = (void*(*)(const void*))&sid_dup;
 193         return (DOM_SID*)add_copy_to_array(len,
 194                           (void***)array, (const void*)sid, *fn, False);
 195 }
 196