Index: trunk/lib/regfi.c
===================================================================
--- trunk/lib/regfi.c	(revision 182)
+++ trunk/lib/regfi.c	(revision 184)
@@ -947,5 +947,5 @@
   
   for(i=0; i < num_lists; i++)
-    regfi_subkeylist_free(lists[i]);
+    talloc_free(lists[i]);
   free(lists);
 
@@ -1185,5 +1185,5 @@
     if(vk->valuename == NULL)
     {
-      regfi_free_value(vk);
+      talloc_free(vk);
       return;
     }
@@ -1279,5 +1279,5 @@
     if(nk->keyname == NULL)
     {
-      regfi_free_key(nk);
+      talloc_free(nk);
       return;
     }
@@ -1333,5 +1333,5 @@
       if(strict)
       {
-	regfi_free_key(nk);
+	talloc_free(nk);
 	return NULL;
       }
@@ -1350,5 +1350,5 @@
 	if(strict)
 	{
-	  regfi_free_key(nk);
+	  talloc_free(nk);
 	  return NULL;
 	}
@@ -1367,5 +1367,5 @@
       if(strict)
       {
-	regfi_free_key(nk);
+	talloc_free(nk);
 	return NULL;
       }
@@ -1400,4 +1400,11 @@
   void* failure_ptr = NULL;
   
+  max_size = regfi_calc_maxsize(file, offset);
+  if(max_size < 0)
+    return NULL;
+
+  if(file->sk_cache == NULL)
+    return regfi_parse_sk(file, offset, max_size, strict);
+
   if(!regfi_lock(file, file->sk_lock, "regfi_load_sk"))
     return NULL;
@@ -1412,8 +1419,4 @@
   if(ret_val == NULL)
   {
-    max_size = regfi_calc_maxsize(file, offset);
-    if(max_size < 0)
-      return NULL;
-
     ret_val = regfi_parse_sk(file, offset, max_size, strict);
     if(ret_val == NULL)
@@ -1424,12 +1427,16 @@
       *(uint32_t*)failure_ptr = REGFI_OFFSET_NONE;
       lru_cache_update(file->sk_cache, &offset, 4, failure_ptr);
+
+      /* Let the cache be the only owner of this */
+      talloc_unlink(NULL, failure_ptr);
       return NULL;
     }
-
-    lru_cache_update(file->sk_cache, &offset, 4, ret_val);
   }
 
   if(!regfi_unlock(file, file->sk_lock, "regfi_load_sk"))
-    return NULL;
+  {
+    talloc_unlink(NULL, ret_val);
+    return NULL;
+  }
 
   return ret_val;
@@ -1597,6 +1604,8 @@
   cache_secret = 0x15DEAD05^time(NULL)^(getpid()<<16);
 
-  /* Cache an unlimited number of SK records.  Typically there are very few. */
-  rb->sk_cache = lru_cache_create_ctx(rb, 0, cache_secret, true);
+  if(REGFI_CACHE_SK)
+    rb->sk_cache = lru_cache_create_ctx(rb, 64, cache_secret, true);
+  else
+    rb->sk_cache = NULL;
 
   /* success */
@@ -1678,28 +1687,9 @@
 /******************************************************************************
  *****************************************************************************/
-void regfi_free_key(REGFI_NK_REC* nk)
-{
-  regfi_subkeylist_free(nk->subkeys);
-  talloc_free(nk);
-}
-
-
-/******************************************************************************
- *****************************************************************************/
-void regfi_free_value(REGFI_VK_REC* vk)
-{
-  talloc_free(vk);
-}
-
-
-/******************************************************************************
- *****************************************************************************/
-void regfi_subkeylist_free(REGFI_SUBKEY_LIST* list)
-{
-  if(list != NULL)
-  {
-    talloc_free(list);
-  }
-}
+void regfi_free_record(const void* record)
+{
+  talloc_unlink(NULL, (void*)record);
+}
+
 
 
@@ -1731,5 +1721,5 @@
   }
   ret_val->cur_key = root;
-  talloc_steal(ret_val, root);
+  talloc_reference(ret_val, root);
 
   ret_val->key_positions = void_stack_new(REGFI_MAX_DEPTH);
@@ -1783,8 +1773,8 @@
   {
     talloc_free(pos);
-    regfi_free_key(subkey);
+    talloc_unlink(NULL, subkey);
     return false;
   }
-  talloc_steal(i, subkey);
+  talloc_reference(i, subkey);
 
   i->cur_key = subkey;
@@ -1806,5 +1796,5 @@
     return false;
 
-  regfi_free_key(i->cur_key);
+  talloc_unlink(i, i->cur_key);
   i->cur_key = pos->nk;
   i->cur_subkey = pos->cur_subkey;
@@ -1847,5 +1837,5 @@
     else
     {
-      regfi_free_key(subkey);
+      talloc_unlink(NULL, subkey);
       subkey = (REGFI_NK_REC*)regfi_iterator_next_subkey(i);
     }
@@ -1858,5 +1848,5 @@
   }
 
-  regfi_free_key(subkey);
+  talloc_unlink(NULL, subkey);
   return true;
 }
@@ -1909,5 +1899,5 @@
 /******************************************************************************
  *****************************************************************************/
-REGFI_NK_REC* regfi_iterator_first_subkey(REGFI_ITERATOR* i)
+const REGFI_NK_REC* regfi_iterator_first_subkey(REGFI_ITERATOR* i)
 {
   i->cur_subkey = 0;
@@ -1918,5 +1908,5 @@
 /******************************************************************************
  *****************************************************************************/
-REGFI_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
+const REGFI_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
 {
   uint32_t nk_offset;
@@ -1929,6 +1919,6 @@
   nk_offset = i->cur_key->subkeys->elements[i->cur_subkey].offset;
 
-  return regfi_load_key(i->f, nk_offset+REGFI_REGF_SIZE, i->string_encoding, 
-			true);
+  return regfi_load_key(i->f, nk_offset+REGFI_REGF_SIZE, 
+			i->string_encoding, true);
 }
 
@@ -1937,7 +1927,7 @@
  *****************************************************************************/
 /* XXX: some way of indicating reason for failure should be added. */
-REGFI_NK_REC* regfi_iterator_next_subkey(REGFI_ITERATOR* i)
-{
-  REGFI_NK_REC* subkey;
+const REGFI_NK_REC* regfi_iterator_next_subkey(REGFI_ITERATOR* i)
+{
+  const REGFI_NK_REC* subkey;
 
   i->cur_subkey++;
@@ -1955,5 +1945,5 @@
 bool regfi_iterator_find_value(REGFI_ITERATOR* i, const char* value_name)
 {
-  REGFI_VK_REC* cur;
+  const REGFI_VK_REC* cur;
   bool found = false;
   uint32_t old_value = i->cur_value;
@@ -1973,5 +1963,5 @@
     else
     {
-      regfi_free_value(cur);
+      regfi_free_record(cur);
       cur = regfi_iterator_next_value(i);
     }
@@ -1984,5 +1974,5 @@
   }
 
-  regfi_free_value(cur);
+  regfi_free_record(cur);
   return true;
 }
@@ -1991,5 +1981,5 @@
 /******************************************************************************
  *****************************************************************************/
-REGFI_VK_REC* regfi_iterator_first_value(REGFI_ITERATOR* i)
+const REGFI_VK_REC* regfi_iterator_first_value(REGFI_ITERATOR* i)
 {
   i->cur_value = 0;
@@ -2000,5 +1990,5 @@
 /******************************************************************************
  *****************************************************************************/
-REGFI_VK_REC* regfi_iterator_cur_value(REGFI_ITERATOR* i)
+const REGFI_VK_REC* regfi_iterator_cur_value(REGFI_ITERATOR* i)
 {
   REGFI_VK_REC* ret_val = NULL;
@@ -2021,7 +2011,7 @@
 /******************************************************************************
  *****************************************************************************/
-REGFI_VK_REC* regfi_iterator_next_value(REGFI_ITERATOR* i)
-{
-  REGFI_VK_REC* ret_val;
+const REGFI_VK_REC* regfi_iterator_next_value(REGFI_ITERATOR* i)
+{
+  const REGFI_VK_REC* ret_val;
 
   i->cur_value++;
@@ -2036,6 +2026,6 @@
 /******************************************************************************
  *****************************************************************************/
-REGFI_CLASSNAME* regfi_iterator_fetch_classname(REGFI_ITERATOR* i, 
-						const REGFI_NK_REC* key)
+const REGFI_CLASSNAME* regfi_iterator_fetch_classname(REGFI_ITERATOR* i,
+						      const REGFI_NK_REC* key)
 {
   REGFI_CLASSNAME* ret_val;
@@ -2100,6 +2090,6 @@
 /******************************************************************************
  *****************************************************************************/
-REGFI_DATA* regfi_iterator_fetch_data(REGFI_ITERATOR* i, 
-				      const REGFI_VK_REC* value)
+const REGFI_DATA* regfi_iterator_fetch_data(REGFI_ITERATOR* i, 
+					    const REGFI_VK_REC* value)
 {
   REGFI_DATA* ret_val = NULL;
@@ -2140,19 +2130,4 @@
   
   return ret_val;
-}
-
-
-/******************************************************************************
- *****************************************************************************/
-void regfi_free_classname(REGFI_CLASSNAME* classname)
-{
-  talloc_free(classname);
-}
-
-/******************************************************************************
- *****************************************************************************/
-void regfi_free_data(REGFI_DATA* data)
-{
-  talloc_free(data);
 }
 
