static void NPySecObj_dealloc(NPySecObj* self) { //printf("NPySecObj_dealloc %lx %s\n", (long)self, secname(self->sec_)); if (self->sec_) { if (self->sec_->prop) { self->sec_->prop->dparam[PROP_PY_INDEX]._pvoid = 0; } if (self->name_) { delete [] self->name_; } if (self->sec_->prop && !self->sec_->prop->dparam[0].sym) { sec_free(self->sec_->prop->dparam[8].itm); }else{ section_unref(self->sec_); } } ((PyObject*)self)->ob_type->tp_free((PyObject*)self); }
void egg_secure_free_full (void *memory, int flags) { Block *block = NULL; if (memory == NULL) return; DO_LOCK (); /* Find out where it belongs to */ for (block = all_blocks; block; block = block->next) { if (sec_is_valid_word (block, memory)) break; } #ifdef WITH_VALGRIND /* We like valgrind's warnings, so give it a first whack at checking for errors */ if (block != NULL || !(flags & GKR_SECURE_USE_FALLBACK)) VALGRIND_FREELIKE_BLOCK (memory, sizeof (word_t)); #endif if (block != NULL) { sec_free (block, memory); if (block->used == 0) sec_block_destroy (block); } DO_UNLOCK (); if (!block) { if ((flags & GKR_SECURE_USE_FALLBACK)) { egg_memory_fallback (memory, 0); } else { if (egg_secure_warnings) fprintf (stderr, "memory does not belong to mate-keyring: 0x%08lx\n", (unsigned long)memory); ASSERT (0 && "memory does does not belong to mate-keyring"); } } }
static void* sec_realloc (Block *block, void *memory, size_t length) { Cell *cell, *other; word_t *word; size_t n_words; size_t valid; void *alloc; /* Standard realloc behavior, should have been handled elsewhere */ ASSERT (memory != NULL); ASSERT (length > 0); /* Dig out where the meta should be */ word = memory; --word; #ifdef WITH_VALGRIND VALGRIND_MAKE_MEM_DEFINED (word, sizeof (word_t)); #endif ASSERT (sec_is_valid_word (block, word)); ASSERT (pool_valid (*word)); cell = *word; /* Validate that it's actually for real */ sec_check_guards (cell); ASSERT (cell->allocated > 0); ASSERT (cell->next == NULL); ASSERT (cell->prev == NULL); /* The amount of valid data */ valid = cell->allocated; /* How many words we actually want */ n_words = sec_size_to_words (length) + 2; /* Less memory is required than is in the cell */ if (n_words <= cell->n_words) { /* TODO: No shrinking behavior yet */ cell->allocated = length; alloc = sec_cell_to_memory (cell); #ifdef WITH_VALGRIND VALGRIND_MAKE_MEM_DEFINED (alloc, length); #endif /* * Even though we may be reusing the same cell, that doesn't * mean that the allocation is shrinking. It could have shrunk * and is now expanding back some. */ if (length < valid) return sec_clear_memory (alloc, length, valid); else return alloc; } /* Need braaaaaiiiiiinsss... */ while (cell->n_words < n_words) { /* See if we have a neighbor who can give us some memory */ other = sec_neighbor_after (block, cell); if (!other || other->allocated != 0) break; /* Eat the whole neighbor if not too big */ if (n_words - cell->n_words + WASTE >= other->n_words) { cell->n_words += other->n_words; sec_write_guards (cell); sec_remove_cell_ring (&block->unused, other); pool_free (other); /* Steal from the neighbor */ } else { other->words += n_words - cell->n_words; other->n_words -= n_words - cell->n_words; sec_write_guards (other); cell->n_words = n_words; sec_write_guards (cell); } } if (cell->n_words >= n_words) { cell->allocated = length; alloc = sec_cell_to_memory (cell); #ifdef WITH_VALGRIND VALGRIND_MAKE_MEM_DEFINED (alloc, length); #endif return sec_clear_memory (alloc, valid, length); } /* That didn't work, try alloc/free */ alloc = sec_alloc (block, length); if (alloc) { memcpy (alloc, memory, valid); sec_free (block, memory); } return alloc; }