src/install/acquire/cabinet-memory.c

   1 /* $Id$
   2  * cabextract memory allocation for acquiration installation utility
   3  * Copyright (C) 2003 Jan Kratochvil <project-captive@jankratochvil.net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; exactly version 2 of June 1991 is required
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19
  20 #include "config.h"
  21
  22 #include "cabinet-memory.h"     /* self */
  23 #include <glib/gmessages.h>
  24 #include <glib/ghash.h>
  25 #include <glib/gtypes.h>
  26 #include <glib/gslist.h>
  27
  28
  29 struct _CaptiveAcquireCabinetMemoryObject {
  30         GObject parent_instance;
  31
  32         /*< private >*/
  33         GHashTable *memory_hash;
  34         gpointer data;
  35         gsize data_size;
  36         };
  37 struct _CaptiveAcquireCabinetMemoryObjectClass {
  38         GObjectClass parent_class;
  39         };
  40
  41 static CaptiveAcquireCabinetMemoryObject *memory_object;
  42 static GSList *memory_object_slist;
  43
  44 static gpointer captive_acquire_cabinet_memory_object_parent_class=NULL;
  45
  46 static void captive_acquire_cabinet_memory_object_finalize_foreach
  47                 (gpointer mem /* key */,gpointer mem_val,gpointer user_data /* unused */)
  48 {
  49         g_return_if_fail(mem!=NULL);
  50         g_return_if_fail(mem_val!=NULL);
  51         g_return_if_fail(mem==mem_val);
  52
  53         g_free(mem);
  54 }
  55
  56 static void captive_acquire_cabinet_memory_object_finalize(CaptiveAcquireCabinetMemoryObject *memory)
  57 {
  58         g_return_if_fail(memory!=NULL);
  59         g_return_if_fail(memory!=memory_object);
  60
  61         g_hash_table_foreach(memory->memory_hash,
  62                         captive_acquire_cabinet_memory_object_finalize_foreach, /* func */
  63                         NULL);  /* user_data; unused */
  64
  65         g_hash_table_destroy(memory->memory_hash);
  66
  67         g_free(memory->data);
  68         memory->data=NULL;
  69         memory->data_size=0;
  70
  71         G_OBJECT_CLASS(captive_acquire_cabinet_memory_object_parent_class)->finalize((GObject *)memory);
  72 }
  73
  74 static void captive_acquire_cabinet_memory_object_class_init(CaptiveAcquireCabinetMemoryObjectClass *class)
  75 {
  76 GObjectClass *gobject_class=G_OBJECT_CLASS(class);
  77
  78         captive_acquire_cabinet_memory_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class)));
  79         gobject_class->finalize=(void (*)(GObject *object))captive_acquire_cabinet_memory_object_finalize;
  80 }
  81
  82 static void captive_acquire_cabinet_memory_object_init(CaptiveAcquireCabinetMemoryObject *memory_object)
  83 {
  84         memory_object->memory_hash=g_hash_table_new(g_direct_hash,g_direct_equal);
  85 }
  86
  87 GType captive_acquire_cabinet_memory_object_get_type(void)
  88 {
  89 static GType captive_acquire_cabinet_memory_object_type=0;
  90
  91         if (!captive_acquire_cabinet_memory_object_type) {
  92 static const GTypeInfo captive_acquire_cabinet_memory_object_info={
  93                                 sizeof(CaptiveAcquireCabinetMemoryObjectClass),
  94                                 NULL,   /* base_init */
  95                                 NULL,   /* base_finalize */
  96                                 (GClassInitFunc)captive_acquire_cabinet_memory_object_class_init,
  97                                 NULL,   /* class_finalize */
  98                                 NULL,   /* class_data */
  99                                 sizeof(CaptiveAcquireCabinetMemoryObject),
 100                                 5,      /* n_preallocs */
 101                                 (GInstanceInitFunc)captive_acquire_cabinet_memory_object_init,
 102                                 };
 103
 104                 captive_acquire_cabinet_memory_object_type=g_type_register_static(G_TYPE_OBJECT,
 105                                 "CaptiveAcquireCabinetMemoryObject",&captive_acquire_cabinet_memory_object_info,0);
 106                 }
 107
 108         return captive_acquire_cabinet_memory_object_type;
 109 }
 110
 111 CaptiveAcquireCabinetMemoryObject *acquire_cabinet_memory_object_new(void)
 112 {
 113         return g_object_new(
 114                         CAPTIVE_ACQUIRE_CABINET_MEMORY_TYPE_OBJECT,     /* object_type */
 115                         NULL);  /* first_property_name */
 116 }
 117
 118 void acquire_cabinet_memory_object_push(CaptiveAcquireCabinetMemoryObject *memory)
 119 {
 120         g_return_if_fail(CAPTIVE_ACQUIRE_CABINET_MEMORY_IS_OBJECT(memory));
 121
 122         if (memory_object)
 123                 memory_object_slist=g_slist_prepend(memory_object_slist,memory_object);
 124         memory_object=memory;
 125 }
 126
 127 /* 'memory' is just a sanity check */
 128 void acquire_cabinet_memory_object_pop(CaptiveAcquireCabinetMemoryObject *memory)
 129 {
 130         g_return_if_fail(CAPTIVE_ACQUIRE_CABINET_MEMORY_IS_OBJECT(memory));
 131         g_return_if_fail(memory==memory_object);
 132
 133         if (!memory_object_slist)
 134                 memory_object=NULL;
 135         else {
 136                 memory_object=memory_object_slist->data;
 137                 g_assert(memory_object!=NULL);
 138                 memory_object_slist=g_slist_delete_link(memory_object_slist,memory_object_slist);
 139                 }
 140 }
 141
 142 gpointer acquire_cabinet_memory_malloc(gulong n_bytes)
 143 {
 144 gpointer r;
 145
 146         g_return_val_if_fail(CAPTIVE_ACQUIRE_CABINET_MEMORY_IS_OBJECT(memory_object),NULL);
 147
 148         r=g_malloc(n_bytes);
 149         g_assert((!r)==(!n_bytes));
 150         if (r)
 151                 g_hash_table_insert(memory_object->memory_hash,r,r);
 152
 153         return r;
 154 }
 155
 156 gpointer acquire_cabinet_memory_malloc0(gulong n_bytes)
 157 {
 158 gpointer r;
 159
 160         g_return_val_if_fail(CAPTIVE_ACQUIRE_CABINET_MEMORY_IS_OBJECT(memory_object),NULL);
 161
 162         r=g_malloc0(n_bytes);
 163         g_assert((!r)==(!n_bytes));
 164         if (r)
 165                 g_hash_table_insert(memory_object->memory_hash,r,r);
 166
 167         return r;
 168 }
 169
 170 gpointer acquire_cabinet_memory_realloc(gpointer mem,gulong n_bytes)
 171 {
 172 gpointer r;
 173 gboolean errbool;
 174
 175         g_return_val_if_fail(CAPTIVE_ACQUIRE_CABINET_MEMORY_IS_OBJECT(memory_object),NULL);
 176
 177         if (mem!=NULL) {
 178                 errbool=g_hash_table_remove(memory_object->memory_hash,mem);
 179                 g_assert(errbool==TRUE);
 180                 }
 181         r=g_realloc(mem,n_bytes);
 182         g_assert((!r)==(!n_bytes));
 183         if (r)
 184                 g_hash_table_insert(memory_object->memory_hash,r,r);
 185
 186         return r;
 187 }
 188
 189 void acquire_cabinet_memory_free(gpointer mem)
 190 {
 191 gboolean errbool;
 192
 193         g_return_if_fail(CAPTIVE_ACQUIRE_CABINET_MEMORY_IS_OBJECT(memory_object));
 194
 195         if (mem!=NULL) {
 196                 errbool=g_hash_table_remove(memory_object->memory_hash,mem);
 197                 g_assert(errbool==TRUE);
 198                 }
 199         g_free(mem);
 200 }
 201
 202 /* UGLY HACK for 'cabextract/cabextract.c/decomp_state' */
 203 gpointer acquire_cabinet_memory_data_get(gsize size)
 204 {
 205         g_return_val_if_fail(size>0,NULL);
 206         g_return_val_if_fail(CAPTIVE_ACQUIRE_CABINET_MEMORY_IS_OBJECT(memory_object),NULL);
 207
 208         if (!memory_object->data_size) {
 209                 memory_object->data_size=size;
 210                 memory_object->data=g_malloc0(memory_object->data_size);
 211                 }
 212
 213         g_assert(memory_object->data_size==size);
 214         g_assert(memory_object->data!=NULL);
 215
 216         return memory_object->data;
 217 }