diff -Naur ../orig/libpst-0.5.1/define.h libpst64-060926/define.h
--- ../orig/libpst-0.5.1/define.h	2004-11-17 07:48:03.000000000 -0700
+++ libpst64-060926/define.h	2006-09-26 14:09:55.000000000 -0600
@@ -5,7 +5,7 @@
  *            dave.s@earthcorp.com
  */
 
-//#define DEBUG_ALL
+#define DEBUG_ALL
 #ifndef DEFINEH_H
 #define DEFINEH_H
 
diff -Naur ../orig/libpst-0.5.1/generic.c libpst64-060926/generic.c
--- ../orig/libpst-0.5.1/generic.c	1969-12-31 17:00:00.000000000 -0700
+++ libpst64-060926/generic.c	2006-09-26 14:09:55.000000000 -0600
@@ -0,0 +1,110 @@
+// {{{ includes
+
+#include <ctype.h>
+#include <errno.h>
+#include <malloc.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "generic.h"
+
+#ifdef WITH_DMALLOC
+#include <dmalloc.h>
+#endif
+
+// }}}
+
+// {{{ Macros: ASSERT(), DIE(), F_MALLOC()
+void pDIE( char *fmt, ... ) // {{{ Cough...cough
+{
+	va_list ap;
+	va_start( ap, fmt );
+        //fprintf( stderr, "Fatal error (will segfault): ");
+	vfprintf( stderr, fmt, ap );
+	fprintf( stderr, "\n" );
+	va_end(ap);
+        raise( SIGSEGV );
+}
+// }}}
+void pWARN( char *fmt, ... ) // {{{ Cough...cough
+{
+	va_list ap;
+	va_start( ap, fmt );
+        fprintf( stderr, "WARNING: ");
+	vfprintf( stderr, fmt, ap );
+	fprintf( stderr, "\n" );
+	va_end(ap);
+}
+// }}}
+void *F_MALLOC( size_t size ) // {{{ malloc() but dumps core when it fails
+{
+	void *result;
+
+	result = malloc( size );
+	ASSERT( NULL != result, "malloc() failure." );
+
+	return result;
+}
+// }}}
+void *F_REALLOC( void *p, size_t size ) // {{{ realloc() but dumps core when it fails
+{
+	void *result;
+
+	//if( NULL != p ) hexdump((char*)p - 128, 0, 128, 1 );
+	if(!p) {
+		ASSERT( NULL != ( result = malloc( size ) ), "malloc() failure." );
+	}
+	else {
+		ASSERT( NULL != ( result = realloc( p, size ) ), "realloc() failure." );
+	}
+
+	//hexdump((char*)result - 128, 0, 128, 1 );
+	fflush(stderr);
+	return result;
+}
+// }}}
+// }}}
+// {{{ Program logging/debug output
+int DEBUG_LEVEL = DB_INFO;
+
+void db_default( char *file, int line, int level, char *fmt, ... ) // {{{
+{
+	va_list ap;
+	if( level <= DEBUG_LEVEL ) {
+		switch( level ) {
+			case DB_CRASH:
+				fprintf(stderr, "CRASH");
+				break;
+			case DB_ERR:
+				fprintf(stderr, "ERROR");
+				break;
+			case DB_WARN:
+				fprintf(stderr, "WARNING");
+				break;
+			case DB_INFO:
+			case DB_VERB:
+				break;
+			default:
+				fprintf(stderr, "DEBUG(%d)", level );
+		}
+
+		if( level <= DB_WARN )
+			fprintf(stderr, " (%s:%d)", file, line );
+
+		if( DB_INFO != level && DB_VERB != level )
+			fprintf(stderr, ": ");
+
+		va_start( ap, fmt );
+		vfprintf(stderr, fmt, ap );
+		fprintf(stderr, "\n" );
+		va_end( ap );
+	}
+} // }}}
+
+void (*dbfunc)(char *file, int line, int level, char *fmt, ...) = &db_default;
+
+//#define DEBUG(x) { x; }
+//#define DEBUG(x) ;
+// }}}
diff -Naur ../orig/libpst-0.5.1/generic.h libpst64-060926/generic.h
--- ../orig/libpst-0.5.1/generic.h	1969-12-31 17:00:00.000000000 -0700
+++ libpst64-060926/generic.h	2006-09-26 14:09:55.000000000 -0600
@@ -0,0 +1,48 @@
+/* {{{ Generic.h - thigns every program does:
+ *
+ * - user output (log, debug, etc)
+ * - crash and burn
+ * - allocate memory (or explode)
+ * }}} */
+#ifndef GENERIC_H
+#define GENERIC_H
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+/***************************************************/
+
+#define LOAD_DEBUG 1
+
+#define DIE(...) { fprintf(stderr, "Fatal Error at %s,%d: ", __FILE__, __LINE__); pDIE(__VA_ARGS__); }
+
+//#define WARN(...) { fprintf(stderr, "WARN: %s,%d: ", __FILE__, __LINE__); pWARN(__VA_ARGS__); }
+void pDIE( char *fmt, ... );
+//void pWARN( char *fmt, ... );
+
+#define WARN(...) DB( DB_WARN, __VA_ARGS__ )
+#define ASSERT(x,...) { if( !(x) ) DIE( __VA_ARGS__ ); }
+
+void *F_MALLOC( size_t size );
+void *F_REALLOC( void *p, size_t size );
+
+#define DO_DEBUG 0
+#define DEBUG(x) if( DO_DEBUG ) { x; }
+#define STUPID_CR "\r\n"
+
+#define DB_CRASH   0 // crashing
+#define DB_ERR     1 // error
+#define DB_WARN    2 // warning
+#define DB_INFO    3 // normal, but significant, condition
+#define DB_VERB	   4 // verbose information
+#define DB_0       5 // debug-level message
+#define DB_1       6 // debug-level message
+#define DB_2       7 // debug-level message
+
+extern int DEBUG_LEVEL;
+extern void (*dbfunc)(char *file, int line, int level, char *fmt, ...);
+
+#define DB(...) { dbfunc( __FILE__, __LINE__, __VA_ARGS__ ); }
+
+int set_db_function( void (*func)( char *file, int line, int level, char *fmt, ...) );
+
+#endif
diff -Naur ../orig/libpst-0.5.1/libpst.c libpst64-060926/libpst.c
--- ../orig/libpst-0.5.1/libpst.c	2004-11-17 07:48:04.000000000 -0700
+++ libpst64-060926/libpst.c	2006-09-26 14:09:55.000000000 -0600
@@ -4,6 +4,7 @@
  * Written by David Smith
  *            dave.s@earthcorp.com
  */
+//{{{
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
@@ -12,11 +13,15 @@
 #include <limits.h>
 #include <wchar.h>
 
+#include <signal.h>
 #include <errno.h>
 #include <sys/stat.h> //mkdir
 #include <fcntl.h> // for Win32 definition of _O_BINARY
 #include "define.h"
 #include "libstrfunc.h"
+#include "vbuf.h"
+
+#define ASSERT(x) { if(!(x)) raise( SIGSEGV ); }
 
 #ifdef _MSC_VER
 # include <windows.h>
@@ -45,30 +50,54 @@
 //#define LE32_CPU(x) {}
 //#define LE16_CPU(x) {}
 //#endif // _MSC_VER
-
-#define FILE_SIZE_POINTER 0xA8
-#define INDEX_POINTER 0xC4
-#define SECOND_POINTER 0xBC
+// }}}
+#define FILE_SIZE_POINTER32 0xA8
+#define INDEX_POINTER32 0xC4
+#define INDEX_COUNT32 0xC0
+#define SECOND_POINTER32 0xBC
+#define SECOND_COUNT32 0xB8
 #define INDEX_DEPTH 0x4C
 #define SECOND_DEPTH 0x5C
 // the encryption setting could be at 0x1CC. Will require field testing
-#define ENC_OFFSET 0x1CD
+#define ENC_OFFSET32 0x1CD
 // says the type of index we have
-#define INDEX_TYPE_OFFSET 0x0A
+#define INDEX_TYPE_OFFSET32 0x0A
+#define INDEX_TYPE32 0x0E
+#define INDEX_TYPE64 0x17 //I think this is wrong
 
 // for the 64bit 2003 outlook PST we need new file offsets
 // perhaps someone can figure out the header format for the pst files...
-#define FILE_SIZE_POINTER_64 0xB8
-#define INDEX_POINTER_64 0xF0
-#define SECOND_POINTER_64 0xE0
+#define FILE_SIZE_POINTER64 0xB8
+#define INDEX_POINTER64 0xF0
+#define INDEX_COUNT64 0xE8
+#define SECOND_POINTER64 0xE0
+#define SECOND_COUNT64 0xD8
+#define INDEX_TYPE_OFFSET64 0x0A
+#define ENC_OFFSET64 0x201
+
+#define FILE_SIZE_POINTER ((do_read64)?FILE_SIZE_POINTER64:FILE_SIZE_POINTER32)
+#define INDEX_POINTER ((do_read64)?INDEX_POINTER64:INDEX_POINTER32)
+#define INDEX_TYPE_OFFSET ((do_read64)?INDEX_TYPE_OFFSET64:INDEX_TYPE_OFFSET32)
+#define INDEX_TYPE ((do_read64)?INDEX_TYPE64:INDEX_TYPE32)
+#define SECOND_POINTER ((do_read64)?SECOND_POINTER64:SECOND_POINTER32)
+#define SECOND_COUNT ((do_read64)?SECOND_COUNT64:SECOND_COUNT32)
+#define ENC_OFFSET ((do_read64)?ENC_OFFSET64:ENC_OFFSET32)
+#define INDEX_COUNT ((do_read64)?INDEX_COUNT64:INDEX_COUNT32)
 
 #define PST_SIGNATURE 0x4E444221
 
-struct _pst_table_ptr_struct{
+int do_read64 = 0; //set this to 1 in order to try and read 64-bit pst files (Outlook 2003)
+
+struct _pst_table_ptr_struct32{
   int32_t start;
   int32_t u1;
   int32_t offset;
 };
+struct _pst_table_ptr_structn{
+  int64_t start;
+  int64_t u1;
+  int64_t offset;
+};
 
 typedef struct _pst_block_header {
   int16_t type;
@@ -119,6 +148,26 @@
     0xd4, 0xe1, 0x11, 0xd0, 0x08, 0x8b, 0x2a, 0xf2,
     0xed, 0x9a, 0x64, 0x3f, 0xc1, 0x6c, 0xf9, 0xec}; /*0xff*/
 
+void set_read64() { do_read64 = 1; } 
+
+void dump_desc( off_t off, int depth, int i, pst_descn *desc_rec ) { // {{{
+
+	//desc_rec->d_id = 0x0102030405060708;
+      DEBUG_INDEX(("%08x [%i] Item(%#x) = [d_id = %#llx, desc_id = %#llx, "
+		  "list_id = %#llx, parent_id = %#x, u1 = %#x] %#x %p %p\n",
+		  off,
+		  depth, i, desc_rec->d_id, 
+		  desc_rec->desc_id, desc_rec->list_id, desc_rec->parent_id, desc_rec->u1));
+      DEBUG_HEXDUMPC( (char*)desc_rec, sizeof( pst_descn ), 0x10 );
+      DEBUG_INDEX(("WTF? %d %x %x %x %x %x\n",
+			      sizeof( u_int32_t ),
+		      (int)(&desc_rec->d_id) - (int)desc_rec,
+		      (int)(&desc_rec->desc_id) - (int)desc_rec,
+		      (int)(&desc_rec->list_id) - (int)desc_rec,
+		      (int)(&desc_rec->parent_id) - (int)desc_rec,
+		      (int)(&desc_rec->u1) - (int)desc_rec ));
+} // }}}
+
 int32_t pst_open(pst_file *pf, char *name, char *mode) {
   u_int32_t sig;
   //  unsigned char ind_type;
@@ -158,9 +207,10 @@
     DEBUG_RET();
     return -1;
   }
+
   _pst_getAtPos(pf->fp, INDEX_TYPE_OFFSET, &(pf->ind_type), sizeof(unsigned char));
   DEBUG_INFO(("index_type = %i\n", pf->ind_type));
-  if (pf->ind_type != 0x0E) {
+  if ( pf->ind_type != INDEX_TYPE) {
     WARN(("unknown index structure. Could this be a new Outlook 2003 PST file?\n"));
     DEBUG_RET();
     return -1;
@@ -170,23 +220,18 @@
   DEBUG_INFO(("encrypt = %i\n", pf->encryption));
   //  pf->encryption = encrypt;
     
-  _pst_getAtPos(pf->fp, SECOND_POINTER-4, &(pf->index2_count), sizeof(pf->index2_count));
-  _pst_getAtPos(pf->fp, SECOND_POINTER, &(pf->index2), sizeof(pf->index2));
-  LE32_CPU(pf->index2_count);
-  LE32_CPU(pf->index2);
+  pf->index2_count = _pst_getIntAtPos(pf->fp, SECOND_COUNT);
+  pf->index2 = _pst_getIntAtPos(pf->fp, SECOND_POINTER );
 
-  _pst_getAtPos(pf->fp, FILE_SIZE_POINTER, &(pf->size), sizeof(pf->size));
-  LE32_CPU(pf->size);
+  pf->size = _pst_getIntAtPos( pf->fp, FILE_SIZE_POINTER );
 
   // very tempting to leave these values set way too high and let the exploration of the tables set them...
   pf->index1_depth = pf->index2_depth = 255;
 
   DEBUG_INFO(("Pointer2 is %#X, count %i[%#x], depth %#x\n", 
     pf->index2, pf->index2_count, pf->index2_count, pf->index2_depth));
-  _pst_getAtPos(pf->fp, INDEX_POINTER-4, &(pf->index1_count), sizeof(pf->index1_count));
-  _pst_getAtPos(pf->fp, INDEX_POINTER, &(pf->index1), sizeof(pf->index1));
-  LE32_CPU(pf->index1_count);
-  LE32_CPU(pf->index1);
+  pf->index1_count = _pst_getIntAtPos(pf->fp, INDEX_COUNT);
+  pf->index1 = _pst_getIntAtPos(pf->fp, INDEX_POINTER);
 
   DEBUG_INFO(("Pointer1 is %#X, count %i[%#x], depth %#x\n", 
     pf->index1, pf->index1_count, pf->index1_count, pf->index1_depth));
@@ -495,18 +540,110 @@
 }
 
 #define BLOCK_SIZE 516
+int _pst_decode_desc( pst_descn *desc, char *buf ) { // {{{
+	int r;
+	if( do_read64 ) {
+
+		DEBUG_INDEX(("Decoding desc64 "));
+		DEBUG_HEXDUMPC(buf, sizeof( pst_descn ), 0x10);
+		memcpy(desc, buf, sizeof( pst_descn ));
+		LE64_CPU(desc->d_id);
+		LE64_CPU(desc->desc_id);
+		LE64_CPU(desc->list_id);
+		LE32_CPU(desc->parent_id);
+		LE32_CPU(desc->u1);
+		r = sizeof( pst_descn );
+	}
+	else {
+		pst_desc32 d32;
+		DEBUG_INDEX(("Decoding desc32 "));
+		DEBUG_HEXDUMPC(buf, sizeof( d32 ), 0x10);
+		memcpy(&d32, buf, sizeof(d32));
+		LE32_CPU(d32.d_id);
+		LE32_CPU(d32.desc_id);
+		LE32_CPU(d32.list_id);
+		LE32_CPU(d32.parent_id);
+
+		desc->d_id = d32.d_id;
+		desc->desc_id = d32.desc_id;
+		desc->list_id = d32.list_id;
+		desc->parent_id = d32.parent_id;
+		desc->u1 = 0;
+
+		r = sizeof( d32 );
+	}
+
+	return r;
+} // }}}
+int _pst_decode_table( struct _pst_table_ptr_structn *table, char *buf ) { // {{{
+
+	if( do_read64 ) {
+
+		DEBUG_INDEX(("Decoding table64"));
+		DEBUG_HEXDUMPC(buf, sizeof( struct _pst_table_ptr_structn ), 0x10);
+		memcpy(table, buf, sizeof( struct _pst_table_ptr_structn ) );
+		LE64_CPU(table->start);
+		LE64_CPU(table->u1);
+		LE64_CPU(table->offset);
+
+		return sizeof( struct _pst_table_ptr_structn );
+	}
+	else {
+		struct _pst_table_ptr_struct32 t32;
+		memcpy(&t32, buf, sizeof(t32));
+		LE32_CPU(t32.start);
+		LE32_CPU(t32.u1);
+		LE32_CPU(t32.offset);
+		table->start = t32.start;
+		table->u1 = t32.u1;
+		table->offset = t32.offset;
+
+		return sizeof( struct _pst_table_ptr_struct32 );
+	}
+	return 0;
+} // }}}
+int _pst_decode_index( pst_index *index, char *buf ) { // {{{
+	if( do_read64 ) {
+
+		DEBUG_INDEX(("Decoding index64"));
+		DEBUG_HEXDUMPC(buf, sizeof( pst_index ), 0x10);
+		memcpy(index, buf, sizeof(pst_index));
+		LE64_CPU(index->id);
+		LE64_CPU(index->offset);
+		LE16_CPU(index->size);
+		LE16_CPU(index->u0);
+		LE16_CPU(index->u1);
+		return sizeof( pst_index );
+	} else {
+		pst_index32 index32;
+		memcpy(&index32, buf, sizeof(pst_index32));
+		LE32_CPU(index32->id);
+		LE32_CPU(index32->offset);
+		LE16_CPU(index32->size);
+		LE16_CPU(index32->u1);
+		index->id = index32.id;
+		index->offset = index32.offset;
+		index->size = index32.size;
+		index->u1 = index32.u1;
+
+		return sizeof( pst_index32 );
+	}
 
-int32_t _pst_build_id_ptr(pst_file *pf, int32_t offset, int32_t depth, int32_t start_val, int32_t end_val) {
-  struct _pst_table_ptr_struct table, table2;
+	return 0;
+} // }}}
+
+int32_t _pst_build_id_ptr(pst_file *pf, off_t offset, int32_t depth, int32_t start_val, int32_t end_val) {
+  struct _pst_table_ptr_structn table, table2;
   pst_index_ll *i_ptr=NULL;
   pst_index index;
   //  int fpos = ftell(pf->fp);
   int32_t x, ret;
   int32_t old = start_val;
+  off_t roff;
   char *buf = NULL, *bptr = NULL;
 
   DEBUG_ENT("_pst_build_id_ptr");
-  if (pf->index1_depth - depth == 0) {
+  if (pf->index1_depth - depth == 0) { // {{{ Leaf table, add indexes to linked list
     // we must be at a leaf table. These are index items
     DEBUG_INDEX(("Reading Items\n"));
     //    fseek(pf->fp, offset, SEEK_SET);
@@ -519,15 +656,14 @@
     }
     bptr = buf;
     //    DEBUG_HEXDUMPC(buf, BLOCK_SIZE, 12);
-    memcpy(&index, bptr, sizeof(index));
-    LE32_CPU(index.id);
-    LE32_CPU(index.offset);
-    LE16_CPU(index.size);
-    LE16_CPU(index.u1);
-    bptr += sizeof(index);
+    roff = offset;
+    bptr += _pst_decode_index( &index, bptr );
 
-    while(index.id != 0 && x < 42 && bptr < buf+BLOCK_SIZE && index.id < end_val) {
-      DEBUG_INDEX(("[%i]%i Item [id = %#x, offset = %#x, u1 = %#x, size = %i(%#x)]\n", depth, ++x, index.id, index.offset, index.u1, index.size, index.size));
+    while(index.id != 0 && x < 42 && bptr < buf+BLOCK_SIZE && index.id < end_val) { // {{{
+      DEBUG_INDEX(("%08x [%i]%i Item [        id = %#llx, offset = %#llx, u1 = %#x, size = %i(%#x)] %p %p\n",
+			      roff,
+	depth, ++x, index.id, index.offset, index.u1,
+	index.size, index.size, buf, bptr ));
       if (index.id & 0x02) {
 	DEBUG_INDEX(("two-bit set!!\n"));
       }
@@ -543,7 +679,7 @@
 	pf->id_depth_ok = 1;
       }
       // u1 could be a flag. if bit 0x2 is not set, it might be deleted
-      //      if (index.u1 & 0x2 || index.u1 & 0x4) { 
+      //      if (index.u1 & 0x2 || index.u1 & 0x4)  
       // ignore the above condition. it doesn't appear to hold
       if (old > index.id) { // then we have back-slid on the new values
 	DEBUG_INDEX(("Back slider detected - Old value [%#x] greater than new [%#x]. Progressing to next table\n", old, index.id));
@@ -551,6 +687,7 @@
 	return 2;
       }
       old = index.id;
+      // {{{ Add index to linked list
       i_ptr = (pst_index_ll*) xmalloc(sizeof(pst_index_ll));
       i_ptr->id = index.id;
       i_ptr->offset = index.offset;    	
@@ -562,15 +699,12 @@
       if (pf->i_head == NULL)
 	pf->i_head = i_ptr;
       pf->i_tail = i_ptr;
-      memcpy(&index, bptr, sizeof(index));
-      LE32_CPU(index.id);
-      LE32_CPU(index.offset);
-      LE16_CPU(index.size);
-      LE16_CPU(index.u1);
-      bptr += sizeof(index);
-    }
-    //    fseek(pf->fp, fpos, SEEK_SET);
-    if (x < 42) { // we have stopped prematurley. Why?
+      // }}}
+
+      roff = offset + (bptr - buf);
+      bptr +=_pst_decode_index( &index, bptr );
+    } // }}}
+    if (x < 42) { // {{{ we have stopped prematurley. Why?
       if (index.id == 0) {
 	DEBUG_INDEX(("Found index.id == 0\n"));
       } else if (!(bptr < buf+BLOCK_SIZE)) {
@@ -581,12 +715,12 @@
       } else {
 	DEBUG_INDEX(("Stopped for unknown reason\n"));
       }
-    }
+    } // }}}
     if (buf) free (buf);
     DEBUG_RET();
     return 2;      
-  } else {
-    // this is then probably a table of offsets to more tables.
+  } // }}}
+  else { // {{{ probably a table of offsets to tables, recurse
     DEBUG_INDEX(("Reading Table Items\n"));
 
     x = 0;
@@ -600,15 +734,10 @@
     bptr = buf;
     //    DEBUG_HEXDUMPC(buf, BLOCK_SIZE, 12);
 
-    memcpy(&table, bptr, sizeof(table));
-    LE32_CPU(table.start);
-    LE32_CPU(table.u1);
-    LE32_CPU(table.offset);
-    bptr += sizeof(table);
-    memcpy(&table2, bptr, sizeof(table));
-    LE32_CPU(table2.start);
-    LE32_CPU(table2.u1);
-    LE32_CPU(table2.offset);
+
+    roff = offset;
+    bptr += _pst_decode_table( &table, bptr );
+    _pst_decode_table( &table2, bptr );
 
     if (start_val != -1 && table.start != start_val) {
       DEBUG_WARN(("This table isn't right. Must be corruption, or I got it wrong!\n"));
@@ -619,7 +748,9 @@
     } 
 
     while (table.start != 0 && bptr < buf+BLOCK_SIZE && table.start < end_val) {
-      DEBUG_INDEX(("[%i] %i Table [start id = %#x, u1 = %#x, offset = %#x]\n", depth, ++x, table.start, table.u1, table.offset));
+      DEBUG_INDEX(("%08x [%i] %i Table [start id = %#x, u1 = %#x, offset = %#x]\n",
+			      roff,
+			      depth, ++x, table.start, table.u1, table.offset));
 
       if (table2.start <= table.start) 
 	// this should only be the case when we come to the end of the table
@@ -643,15 +774,9 @@
       } else {
 	DEBUG_INDEX(("child has returned without a known error [%i]\n", ret));
       }
-      memcpy(&table, bptr, sizeof(table));
-      LE32_CPU(table.start);
-      LE32_CPU(table.u1);
-      LE32_CPU(table.offset);
-      bptr += sizeof(table);
-      memcpy(&table2, bptr, sizeof(table));
-      LE32_CPU(table2.start);
-      LE32_CPU(table2.u1);
-      LE32_CPU(table2.offset);
+      bptr += _pst_decode_table( &table, bptr );
+      roff = offset + ( bptr - buf );
+      _pst_decode_table( &table2, bptr );
     }
 
     if (table.start == 0) {
@@ -669,21 +794,23 @@
     DEBUG_INDEX(("End of table of pointers\n"));
     DEBUG_RET();
     return 3;
-  }
+  } // }}}
   DEBUG_WARN(("ERROR ** Shouldn't be here!\n"));
 
   DEBUG_RET();
   return 1;
 }
 
+
 #define DESC_BLOCK_SIZE 520
-int32_t _pst_build_desc_ptr (pst_file *pf, int32_t offset, int32_t depth, int32_t *high_id, int32_t start_id, 
+int32_t _pst_build_desc_ptr (pst_file *pf, off_t offset, int32_t depth, int32_t *high_id, int32_t start_id, 
 			     int32_t end_val) {
-  struct _pst_table_ptr_struct table, table2;
-  pst_desc desc_rec;
+  struct _pst_table_ptr_structn table, table2;
+  pst_descn desc_rec;
   pst_desc_ll *d_ptr=NULL, *d_par=NULL;
   int32_t i = 0, y, prev_id=-1;
   char *buf = NULL, *bptr;
+  off_t roff;
   
   struct _pst_d_ptr_ll {
     pst_desc_ll * ptr;
@@ -696,8 +823,7 @@
 
   int32_t d_ptr_count = 0;
   DEBUG_ENT("_pst_build_desc_ptr");
-  if (pf->index2_depth-depth == 0) {
-    // leaf node
+  if (pf->index2_depth-depth == 0) { // {{{ leaf node, index it
     if (_pst_read_block_size(pf, offset, DESC_BLOCK_SIZE, &buf, 0, 0) < DESC_BLOCK_SIZE) {
       DEBUG_WARN(("I didn't get all the index that I wanted. _pst_read_block_size returned less than requested\n"));
       DEBUG_RET();
@@ -707,22 +833,17 @@
     
     //DEBUG_HEXDUMPC(buf, DESC_BLOCK_SIZE, 16);
 
-    memcpy(&desc_rec, bptr, sizeof(desc_rec));
-    LE32_CPU(desc_rec.d_id);
-    LE32_CPU(desc_rec.desc_id);
-    LE32_CPU(desc_rec.list_id);
-    LE32_CPU(desc_rec.parent_id);
-    bptr+= sizeof(desc_rec);
+    roff = offset;
+    bptr += _pst_decode_desc( &desc_rec, bptr );
 
     if (end_val <= start_id) {
       DEBUG_WARN(("The end value is BEFORE the start value. This function will quit. Soz. [start:%#x, end:%#x]\n",
 		  start_id, end_val));
     }
 
-    while (i < 0x1F && desc_rec.d_id < end_val && (prev_id == -1 || desc_rec.d_id > prev_id)) {
-      DEBUG_INDEX(("[%i] Item(%#x) = [d_id = %#x, desc_id = %#x, "
-		  "list_id = %#x, parent_id = %#x]\n", depth, i, desc_rec.d_id, 
-		  desc_rec.desc_id, desc_rec.list_id, desc_rec.parent_id));
+    while (i < 0x1F && desc_rec.d_id < end_val && (prev_id == -1 || desc_rec.d_id > prev_id)) { // {{{
+	    DEBUG_INDEX(("Bliss %d: %llx %p %p %p ", i, offset, buf, bptr, bptr ));
+	    dump_desc( roff, depth, i, &desc_rec );
       i++;
 
       if (start_id != -1 && desc_rec.d_id != start_id) {
@@ -737,20 +858,16 @@
       }
 
       if (desc_rec.d_id == 0) {
-	memcpy(&desc_rec, bptr, sizeof(desc_rec));
-	LE32_CPU(desc_rec.d_id);
-	LE32_CPU(desc_rec.desc_id);
-	LE32_CPU(desc_rec.list_id);
-	LE32_CPU(desc_rec.parent_id);
-	bptr+=sizeof(desc_rec);
-	continue;
+	      roff = offset + ( bptr - buf );
+		bptr+=_pst_decode_desc( &desc_rec, bptr );
+		continue;
       }
       prev_id = desc_rec.d_id;
 
       // When duplicates found, just update the info.... perhaps this is correct functionality
       DEBUG_INDEX(("Searching for existing record\n"));
 
-      if (desc_rec.d_id <= *high_id && (d_ptr = _pst_getDptr(pf, desc_rec.d_id)) !=  NULL) { 
+      if (desc_rec.d_id <= *high_id && (d_ptr = _pst_getDptr(pf, desc_rec.d_id)) !=  NULL) { // {{{
 	DEBUG_INDEX(("Updating Existing Values\n"));
 	d_ptr->list_index = _pst_getID(pf, desc_rec.list_id);
 	d_ptr->desc = _pst_getID(pf, desc_rec.desc_id);
@@ -802,7 +919,7 @@
 	      d_ptr_ptr = d_ptr_ptr->next;
 	    }
 
-	    if (d_ptr_ptr == NULL && (d_par = _pst_getDptr(pf, desc_rec.parent_id)) == NULL) {
+	    if (d_ptr_ptr == NULL && (d_par = _pst_getDptr(pf, desc_rec.parent_id)) == NULL) { // {{{
 	      // check in the lost/found list
 	      lf_ptr = lf_head;
 	      while (lf_ptr != NULL && lf_ptr->ptr->id != desc_rec.parent_id) {
@@ -820,7 +937,7 @@
 		d_par = lf_ptr->ptr;
 		DEBUG_INDEX(("Found parent (%#x) in Lost and Found\n", d_par->id));
 	      }
-	    }
+	    } // }}}
 	    
 	    if (d_ptr_ptr != NULL || d_par != NULL) {
 	      if (d_ptr_ptr != NULL) 
@@ -857,7 +974,8 @@
 	  }
 	}
 
-      } else {     
+      } // }}}
+      else {     
 	if (*high_id < desc_rec.d_id) {
 	  DEBUG_INDEX(("Updating New High\n"));
 	  *high_id = desc_rec.d_id;
@@ -866,8 +984,10 @@
 	d_ptr = (pst_desc_ll*) xmalloc(sizeof(pst_desc_ll));
 	//	DEBUG_INDEX(("Item pointer is %p\n", d_ptr));
 	d_ptr->id = desc_rec.d_id;
+	DEBUG_INDEX(("Weird %llx moo", desc_rec.list_id ));
 	d_ptr->list_index = _pst_getID(pf, desc_rec.list_id);
 	d_ptr->desc = _pst_getID(pf, desc_rec.desc_id);
+	//ASSERT( d_ptr->desc != NULL );
 	d_ptr->prev = NULL;
 	d_ptr->next = NULL;
 	d_ptr->parent = NULL;
@@ -876,7 +996,7 @@
 	d_ptr->no_child = 0;
 
         DEBUG_INDEX(("Searching for parent\n"));
-	if (desc_rec.parent_id == 0 || desc_rec.parent_id == desc_rec.d_id) {
+	if (desc_rec.parent_id == 0 || desc_rec.parent_id == desc_rec.d_id) { // {{{
 	  if (desc_rec.parent_id == 0) {
 	    DEBUG_INDEX(("No Parent\n"));
 	  } else {
@@ -888,7 +1008,8 @@
 	    pf->d_head = d_ptr;
 	  d_ptr->prev = pf->d_tail;
 	  pf->d_tail = d_ptr;
-        } else {
+        } // }}}
+	else { // {{{
 	  d_ptr_ptr = d_ptr_head;
 	  while (d_ptr_ptr != NULL && d_ptr_ptr->ptr->id != desc_rec.parent_id) {
 	    d_ptr_ptr = d_ptr_ptr->next;
@@ -947,7 +1068,7 @@
 	    d_ptr->prev = d_par->child_tail;
 	    d_par->child_tail = d_ptr;
 	  }
-	}
+	} // }}}
       }
       // check here to see if d_ptr is the parent of any of the items in the lost / found list
       lf_ptr = lf_head; lf_shd = NULL;
@@ -977,16 +1098,13 @@
 	  lf_ptr = lf_ptr->next;
 	}
       }
-      memcpy(&desc_rec, bptr, sizeof(desc_rec));
-      LE32_CPU(desc_rec.d_id);
-      LE32_CPU(desc_rec.desc_id);
-      LE32_CPU(desc_rec.list_id);
-      LE32_CPU(desc_rec.parent_id);
-      bptr+= sizeof(desc_rec);
-    }
+
+      roff = offset + ( bptr - buf );
+      bptr+= _pst_decode_desc( &desc_rec, bptr );
+    } // }}}
     //    fseek(pf->fp, fpos, SEEK_SET);
-  } else {
-    // hopefully a table of offsets to more tables
+  } // }}}
+  else { // {{{ table of offsets to more tables, recurse
     if (_pst_read_block_size(pf, offset, DESC_BLOCK_SIZE, &buf, 0, 0) < DESC_BLOCK_SIZE) {
       DEBUG_WARN(("didn't read enough desc index. _pst_read_block_size returned less than requested\n"));
       DEBUG_RET();
@@ -995,15 +1113,8 @@
     bptr = buf;
     //    DEBUG_HEXDUMPC(buf, DESC_BLOCK_SIZE, 12);
 
-    memcpy(&table, bptr, sizeof(table));
-    LE32_CPU(table.start);
-    LE32_CPU(table.u1);
-    LE32_CPU(table.offset);
-    bptr+=sizeof(table);
-    memcpy(&table2, bptr, sizeof(table));
-    LE32_CPU(table2.start);
-    LE32_CPU(table2.u1);
-    LE32_CPU(table2.offset);
+    bptr+=_pst_decode_table( &table, bptr );
+    _pst_decode_table( &table2, bptr );
 
     if (start_id != -1 && table.start != start_id) {
       DEBUG_WARN(("This table isn't right. Perhaps we are too deep, or corruption\n"));
@@ -1034,20 +1145,13 @@
 	_pst_build_desc_ptr(pf, table.offset, depth+1, high_id, table.start, table2.start);
       }
 
-      memcpy(&table, bptr, sizeof(table));
-      LE32_CPU(table.start);
-      LE32_CPU(table.u1);
-      LE32_CPU(table.offset);
-      bptr+=sizeof(table);
-      memcpy(&table2, bptr, sizeof(table));
-      LE32_CPU(table2.start);
-      LE32_CPU(table2.u1);
-      LE32_CPU(table2.offset);
+      bptr+=_pst_decode_table( &table, bptr );
+      _pst_decode_table( &table2, bptr );
     }
     if (buf) free(buf);
     DEBUG_RET();
     return 3;
-  }
+  } // }}}
   // ok, lets try freeing the d_ptr_head cache here
   while (d_ptr_head != NULL) {
     d_ptr_ptr = d_ptr_head->next;
@@ -1183,7 +1287,7 @@
   return item;
 }
 
-pst_num_array * _pst_parse_block(pst_file *pf, u_int32_t block_id, pst_index2_ll *i2_head) {
+pst_num_array * _pst_parse_block(pst_file *pf, u_int32_t block_id, pst_index2_ll *i2_head) { // {{{ 
   unsigned char *buf = NULL;
   pst_num_array *na_ptr = NULL, *na_head = NULL;
   pst_block_offset block_offset;
@@ -1194,6 +1298,7 @@
   size_t read_size=0;
   pst_x_attrib_ll *mapptr;
 
+
   struct {
     u_int16_t type;
     u_int16_t ref_type;
@@ -1238,13 +1343,13 @@
 
   //  DEBUG_EMAIL(("About to read %i bytes from offset %#x\n", block->size, block->offset));
 
-  if ((read_size = _pst_ff_getIDblock_dec(pf, block_id, &buf)) == 0) {
-    //  if (_pst_read_block_size(pf, block->offset, block->size, &buf, PST_ENC, 0) < block->size) {
+  if ((read_size = _pst_ff_getIDblock_dec(pf, block_id, &buf)) == 0) { // {{{ error
+    //  if (_pst_read_block_size(pf, block->offset, block->size, &buf, PST_ENC, 0) < block->size) 
     WARN(("Error reading block id %#x\n", block_id));
     if (buf) free (buf);
     DEBUG_RET();
     return NULL;
-  }
+  } // }}}
   DEBUG_EMAIL(("pointer to buf is %p\n", buf));
 
   memcpy(&block_hdr, &(buf[0]), sizeof(block_hdr));
@@ -1255,7 +1360,7 @@
 
   ind_ptr = block_hdr.index_offset;
   
-  if (block_hdr.type == 0xBCEC) { //type 1
+  if (block_hdr.type == 0xBCEC) { // {{{ type 1, populate block_offset
     block_type = 1;
     
     _pst_getBlockOffset(buf, ind_ptr, block_hdr.offset, &block_offset);
@@ -1281,7 +1386,8 @@
     num_list = (to_ptr - fr_ptr)/sizeof(table_rec);
     num_recs = 1; // only going to one object in these blocks
     rec_size = 0; // doesn't matter cause there is only one object
-  } else if (block_hdr.type == 0x7CEC) { //type 2
+  } // }}}
+  else if (block_hdr.type == 0x7CEC) { // {{{ type 2, populate block_offset from seven_c_blk
     block_type = 2;
     
     _pst_getBlockOffset(buf, ind_ptr, block_hdr.offset, &block_offset);
@@ -1340,16 +1446,17 @@
     
     _pst_getBlockOffset(buf, ind_ptr, seven_c_blk.ind2_offset, &block_offset);
     ind2_ptr = block_offset.from;
-  } else {
+  } // }}}
+  else { // {{{ error
     WARN(("ERROR: Unknown block constant - %#X for id %#x\n", block_hdr.type, block_id));
     DEBUG_HEXDUMPC(buf, read_size,0x10);
     if (buf) free(buf);
     DEBUG_RET();
     return NULL;
-  }
+  } // }}}
 
   DEBUG_EMAIL(("Mallocing number of items %i\n", num_recs));
-  while (count_rec < num_recs) {
+  while (count_rec < num_recs) { // {{{
     na_ptr = (pst_num_array*) xmalloc(sizeof(pst_num_array));
     memset(na_ptr, 0, sizeof(pst_num_array));
     if (na_head == NULL) {
@@ -1371,13 +1478,14 @@
     fr_ptr = list_start; // init fr_ptr to the start of the list.
     cur_list = 0;
     stop = 0;
-    while (!stop && cur_list < num_list) { //we will increase fr_ptr as we progress through index
-      if (block_type == 1) {
+    while (!stop && cur_list < num_list) { //{{{ we will increase fr_ptr as we progress through index
+      if (block_type == 1) { // {{{
 	memcpy(&table_rec, &(buf[fr_ptr]), sizeof(table_rec));
 	LE16_CPU(table_rec.type);
 	LE16_CPU(table_rec.ref_type);
 	fr_ptr += sizeof(table_rec);
-      } else if (block_type == 2) {
+      } // }}}
+      else if (block_type == 2) { // {{{
 	// we will copy the table2_rec values into a table_rec record so that we can keep the rest of the code
 	memcpy(&table2_rec, &(buf[fr_ptr]), sizeof(table2_rec));
 	LE16_CPU(table2_rec.ref_type);
@@ -1398,12 +1506,13 @@
 	}
 
 	fr_ptr += sizeof(table2_rec);
-      } else {
+      } // }}}
+      else { // {{{ ERROR
 	WARN(("Missing code for block_type %i\n", block_type));
 	if (buf) free(buf);
 	DEBUG_RET();
 	return NULL;
-      }
+      } // }}}
       cur_list++; // get ready to read next bit from list
       DEBUG_EMAIL(("reading block %i (type=%#x, ref_type=%#x, value=%#x)\n",
 		  x, table_rec.type, table_rec.ref_type, table_rec.value));
@@ -1466,10 +1575,10 @@
 		 || table_rec.ref_type == 0x001E || table_rec.ref_type == 0x0102
 		 || table_rec.ref_type == 0x0040 || table_rec.ref_type == 0x101E
 		 || table_rec.ref_type == 0x0048 || table_rec.ref_type == 0x1102
-		 || table_rec.ref_type == 0x1014) { 
+		 || table_rec.ref_type == 0x1014 || table_rec.ref_type == 0x001F ) { 
 	//contains index_ref to data 
 	LE32_CPU(table_rec.value);
-	if ((table_rec.value & 0x0000000F) == 0xF) { 
+	if ((table_rec.value & 0x0000000F) == 0xF) { // {{{ 
 	  // if value ends in 'F' then this should be an id2 value 
 	  DEBUG_EMAIL(("Found id2 [%#x] value. Will follow it\n", 
 		      table_rec.value)); 
@@ -1483,7 +1592,8 @@
 	  }
 	  DEBUG_EMAIL(("Read %i bytes to a buffer at %p\n",
 		       na_ptr->items[x]->size, na_ptr->items[x]->data));
-	} else if (table_rec.value != 0) {
+	} // }}}
+	else if (table_rec.value != 0) {
 	  if ((table_rec.value >> 4)+ind_ptr > read_size) { 
 	    // check that we will not be outside the buffer we have read
 	    DEBUG_WARN(("table_rec.value [%#x] is outside of block [%#x]\n",
@@ -1507,10 +1617,30 @@
 	  }
 	  
 	  // plus one for good luck (and strings) we will null terminate all reads
-	  na_ptr->items[x]->data = (char*) xmalloc(size+1); 
-	  memcpy(na_ptr->items[x]->data, &(buf[t_ptr]), size);
-	  na_ptr->items[x]->data[size] = '\0'; // null terminate buffer
+	  if( 0x001F == table_rec.ref_type ) {
+		  VBUF_STATIC( strbuf, 1024 );
+		  VBUF_STATIC( unibuf, 1024 );
+		  //need UTF-16 zero-termination
+		  vbset( strbuf, &(buf[t_ptr]), size );
+		  vbappend( strbuf, "\0\0", 2 );
+		  DEBUG_INDEX(("Iconv in: "));
+		  DEBUG_HEXDUMPC( strbuf->b, strbuf->dlen, 0x10 );
+		  vb_utf16to8( unibuf, strbuf->b, strbuf->dlen );
+		  na_ptr->items[x]->data = (char*) xmalloc(unibuf->dlen); 
+		  memcpy(na_ptr->items[x]->data, unibuf->b, unibuf->dlen);
+		  na_ptr->items[x]->size = unibuf->dlen;
+		  DEBUG_INDEX(("Iconv out: "));
+		  DEBUG_HEXDUMPC(na_ptr->items[x]->data, na_ptr->items[x]->size, 0x10 );
+	  }
+	  else {
+		  na_ptr->items[x]->data = (char*) xmalloc(size+1); 
+		  memcpy(na_ptr->items[x]->data, &(buf[t_ptr]), size);
+		  na_ptr->items[x]->data[size] = '\0'; // null terminate buffer
+	  }
 	  
+	  DEBUG_INDEX(("Item Puke: type: %x, ref_type: %x, value: %x\n",
+				  table_rec.type, table_rec.ref_type, table_rec.value ));
+	  DEBUG_HEXDUMPC(na_ptr->items[x]->data, size, 0x10 );
 	  if (table_rec.ref_type == 0xd) {
 	    // there is still more to do for the type of 0xD
 	    type_d_rec = (struct _type_d_rec*) na_ptr->items[x]->data;
@@ -1526,7 +1656,6 @@
 	    } 
 	    DEBUG_EMAIL(("Read %i bytes into a buffer at %p\n",
 			 na_ptr->items[x]->size, na_ptr->items[x]->data));
-	    //	  } 
 	  }
 	} else {
 	  DEBUG_EMAIL(("Ignoring 0 value in offset\n"));
@@ -1548,18 +1677,18 @@
 	return NULL;
       }
       x++;
-    }
+    } // }}}
     DEBUG_EMAIL(("increasing ind2_ptr by %i [%#x] bytes. Was %#x, Now %#x\n",
 		rec_size, rec_size, ind2_ptr, 
 		ind2_ptr+rec_size));
     ind2_ptr += rec_size;
     count_rec++;
-  }
+  } // }}}
   if (buf != NULL)
     free(buf);
   DEBUG_RET();
   return na_head;
-}
+} // }}}
 
 // check if item->email is NULL, and init if so
 #define MALLOC_EMAIL(x) { if (x->email == NULL) { x->email = (pst_item_email*) xmalloc(sizeof(pst_item_email)); memset (x->email, 0, sizeof(pst_item_email));} }
@@ -3384,7 +3513,7 @@
   }
   if (_pst_read_block_size(pf, list->offset, list->size, &buf, PST_NO_ENC,0) < list->size) {
     //an error occured in block read
-    WARN(("block read error occured. offset = %#x, size = %#x\n", list->offset, list->size));
+    WARN(("block read error occured. offset = %#llx, size = %#llx\n", list->offset, list->size));
     DEBUG_RET();
     return NULL;
   }
@@ -3394,7 +3523,7 @@
   LE16_CPU(block_head.count);
 
   if (block_head.type != 0x0002) { // some sort of constant?
-    WARN(("Unknown constant [%#x] at start of id2 values [offset %#x].\n", block_head.type, list->offset));
+    WARN(("Unknown constant [%#x] at start of id2 values [offset %#llx].\n", block_head.type, list->offset));
     DEBUG_RET();
     return NULL;
   }
@@ -3678,7 +3807,7 @@
   return 0;
 }
 
-pst_index_ll * _pst_getID(pst_file* pf, u_int32_t id) {
+pst_index_ll * _pst_getID(pst_file* pf, u_int64_t id) {
   //  static pst_index_ll *old_val = NULL; //this should make it quicker
   pst_index_ll *ptr = NULL;
   DEBUG_ENT("_pst_getID");
@@ -3693,9 +3822,10 @@
   // Dave: I don't think I should do this. next bit. I really think it doesn't work
   // it isn't based on sound principles either.
   // update: seems that the last two sig bits are flags. u tell me!
-  id &= 0xFFFFFFFE; // remove least sig. bit. seems that it might work if I do this
+  //id &= 0xFFFFFFFE; // remove least sig. bit. seems that it might work if I do this
+  id -= (id & 1 );
 
-  DEBUG_INDEX(("Trying to find %#x\n", id));
+  DEBUG_INDEX(("Trying to find %#llx\n", id));
   
   if (ptr == NULL) 
     ptr = pf->i_head;
@@ -3927,6 +4057,9 @@
     return -1;
   }
 
+  DEBUG_INDEX(("_pst_decrypt()"));
+  DEBUG_HEXDUMPC(buf, size, 0x10 );
+
   if (type == PST_COMP_ENCRYPT) {
     x = 0;
     while (x < size) {
@@ -3935,6 +4068,9 @@
       buf[x] = comp_enc[y]; // transpose from encrypt array
       x++;
     }
+
+	  DEBUG_INDEX(("_pst_decrypt() result"));
+	  DEBUG_HEXDUMPC(buf, size, 0x10 );
   } else {
     WARN(("Unknown encryption: %i. Cannot decrypt\n", type));
     DEBUG_RET();
@@ -3944,7 +4080,23 @@
   return 0;
 }
 
-int32_t _pst_getAtPos(FILE *fp, int32_t pos, void* buf, u_int32_t size) {
+int64_t _pst_getIntAtPos(FILE *fp, off_t pos ) {
+	int64_t buf64;
+	int32_t buf32;
+
+	if(do_read64) {
+		_pst_getAtPos(fp, pos, &buf64, sizeof( buf64 ) );
+		LE64_CPU(buf64);
+		return buf64;
+	}
+	else {
+		_pst_getAtPos(fp, pos, &buf32, sizeof( buf32 ) );
+		LE32_CPU(buf32);
+		return buf32;
+	}
+}
+
+int32_t _pst_getAtPos(FILE *fp, off_t pos, void* buf, u_int32_t size) {
   DEBUG_ENT("_pst_getAtPos");
   if (fseek(fp, pos, SEEK_SET) == -1) {
     DEBUG_RET();
diff -Naur ../orig/libpst-0.5.1/libpst.h libpst64-060926/libpst.h
--- ../orig/libpst-0.5.1/libpst.h	2004-11-17 07:48:03.000000000 -0700
+++ libpst64-060926/libpst.h	2006-09-26 14:09:55.000000000 -0600
@@ -117,6 +117,8 @@
 #define PST_APP_LABEL_ANNIVERSARY 9 // Anniversary
 #define PST_APP_LABEL_PHONE_CALL  10// Phone Call
 
+extern int do_read64;
+
 typedef struct _pst_misc_6_struct {
   int32_t i1;
   int32_t i2;
@@ -132,26 +134,72 @@
   int32_t id;
 } pst_entryid;
 
-typedef struct _pst_desc_struct {
+typedef struct _pst_desc_struct32 {
   u_int32_t d_id;
   u_int32_t desc_id;
   u_int32_t list_id;
   u_int32_t parent_id;
-} pst_desc;
+} pst_desc32;
 
-typedef struct _pst_index_struct{
+typedef struct _pst_desc_structn {
+  u_int64_t d_id;
+  u_int64_t desc_id;
+  u_int64_t list_id;
+//  u_int64_t parent_id;
+  u_int32_t parent_id;
+  u_int32_t u1;
+} pst_descn;
+
+typedef struct _pst_index_struct32{
   u_int32_t id;
   int32_t offset;
   u_int16_t size;
   int16_t u1;
+} pst_index32;
+
+/*
+typedef struct _pst_index_struct64{
+  u_int64_t id;
+  int64_t offset;
+  u_int16_t size;
+  int16_t u1;
+} pst_index64;
+*/
+
+typedef struct _pst_index_struct{
+  u_int64_t id;
+  int64_t offset;
+  u_int16_t size;
+  int16_t u0;
+  int32_t u1;
 } pst_index;
 
-typedef struct _pst_index_tree {
+/*
+typedef union _pst_index_struct {
+	pst_index32 i32;
+	pst_index64 i64;
+} pst_index;
+
+#define INDEX_ID(x) ((do_read64)?x.i64.id:x.i32.id)
+#define INDEX_OFFSET(x) ((do_read64)?x.i64.offset:x.i32.offset)
+#define INDEX_SIZE(x) ((do_read64)?x.i64.size:x.i32.size)
+#define INDEX_U1(x) ((do_read64)?x.i64.u1:x.i32.u1)
+*/
+
+typedef struct _pst_index_tree32 {
   u_int32_t id;
   int32_t offset;
-  size_t size;
+  int32_t size;
   int32_t u1;
   struct _pst_index_tree * next;
+} pst_index_ll32;
+
+typedef struct _pst_index_tree {
+  u_int64_t id;
+  int64_t offset;
+  int64_t size;
+  int64_t u1;
+  struct _pst_index_tree * next;
 } pst_index_ll;
 
 typedef struct _pst_index2_tree {
@@ -421,6 +469,10 @@
   int32_t index1_count;
   int32_t index2;
   int32_t index2_count;
+  int64_t index1_64;
+  int64_t index1_count_64;
+  int64_t index2_64;
+  int64_t index2_count_64;
   FILE * fp;
   size_t size;
   unsigned char index1_depth;
@@ -460,6 +512,7 @@
 };
 
 // prototypes
+void set_read64();
 int32_t pst_open(pst_file *pf, char *name, char *mode);
 int32_t pst_close(pst_file *pf);
 pst_desc_ll * pst_getTopOfFolders(pst_file *pf, pst_item *root);
@@ -470,8 +523,8 @@
 pst_desc_ll* pst_getNextDptr(pst_desc_ll* d);
 int32_t pst_load_extended_attributes(pst_file *pf);
 
-int32_t _pst_build_id_ptr(pst_file *pf, int32_t offset, int32_t depth, int32_t start_val, int32_t end_val);
-int32_t _pst_build_desc_ptr (pst_file *pf, int32_t offset, int32_t depth, int32_t *high_id, 
+int32_t _pst_build_id_ptr(pst_file *pf, off_t offset, int32_t depth, int32_t start_val, int32_t end_val);
+int32_t _pst_build_desc_ptr (pst_file *pf, off_t offset, int32_t depth, int32_t *high_id, 
 			     int32_t start_id, int32_t end_val);
 pst_item* _pst_getItem(pst_file *pf, pst_desc_ll *d_ptr);
 void * _pst_parse_item (pst_file *pf, pst_desc_ll *d_ptr);
@@ -485,13 +538,14 @@
 int32_t _pst_free_xattrib(pst_x_attrib_ll *x);
 int32_t _pst_getBlockOffset(char *buf, int32_t i_offset, int32_t offset, pst_block_offset *p);
 pst_index2_ll * _pst_build_id2(pst_file *pf, pst_index_ll* list, pst_index2_ll* head_ptr);
-pst_index_ll * _pst_getID(pst_file* pf, u_int32_t id);
+pst_index_ll * _pst_getID(pst_file* pf, u_int64_t id);
 pst_index_ll * _pst_getID2(pst_index2_ll * ptr, u_int32_t id);
 pst_desc_ll * _pst_getDptr(pst_file *pf, u_int32_t id);
 size_t _pst_read_block_size(pst_file *pf, int32_t offset, size_t size, char ** buf, int32_t do_enc,
 			 unsigned char is_index);
 int32_t _pst_decrypt(unsigned char *buf, size_t size, int32_t type);
-int32_t _pst_getAtPos(FILE *fp, int32_t pos, void* buf, u_int32_t size);
+int64_t _pst_getIntAtPos(FILE *fp, off_t pos);
+int32_t _pst_getAtPos(FILE *fp, off_t pos, void* buf, u_int32_t size);
 int32_t _pst_get (FILE *fp, void *buf, u_int32_t size);
 size_t _pst_ff_getIDblock_dec(pst_file *pf, u_int32_t id, unsigned char **b);
 size_t _pst_ff_getIDblock(pst_file *pf, u_int32_t id, unsigned char** b);
diff -Naur ../orig/libpst-0.5.1/libstrfunc.c libpst64-060926/libstrfunc.c
--- ../orig/libpst-0.5.1/libstrfunc.c	2004-11-17 07:48:03.000000000 -0700
+++ libpst64-060926/libstrfunc.c	2006-09-26 14:09:55.000000000 -0600
@@ -67,3 +67,30 @@
   return _sf_b64_buf=output;
 };
 
+void hexdump(char *hbuf, int start, int stop, int ascii) /* {{{ HexDump all or a part of some buffer */
+{
+        char c;
+        int diff,i;
+
+        while (start < stop ) {
+                diff = stop - start;
+                if (diff > 16) diff = 16;
+
+                fprintf(stderr, ":%08X  ",start);
+
+                for (i = 0; i < diff; i++) {
+                        if( 8 == i ) fprintf( stderr, " " );
+                        fprintf(stderr, "%02X ",(unsigned char)*(hbuf+start+i));
+                }
+                if (ascii) {
+                        for (i = diff; i < 16; i++) fprintf(stderr, "   ");
+                        for (i = 0; i < diff; i++) {
+                                c = *(hbuf+start+i);
+                                fprintf(stderr, "%c", isprint(c) ? c : '.');
+                        }
+                }
+                fprintf(stderr, "\n");
+                start += 16;
+        }
+}
+// }}}
diff -Naur ../orig/libpst-0.5.1/libstrfunc.h libpst64-060926/libstrfunc.h
--- ../orig/libpst-0.5.1/libstrfunc.h	2004-11-17 07:48:03.000000000 -0700
+++ libpst64-060926/libstrfunc.h	2006-09-26 14:09:55.000000000 -0600
@@ -1,2 +1,4 @@
 
 char * base64_encode(void *data, size_t size);
+
+void hexdump(char *hbuf, int start, int stop, int ascii);
diff -Naur ../orig/libpst-0.5.1/lspst.c libpst64-060926/lspst.c
--- ../orig/libpst-0.5.1/lspst.c	2004-11-17 07:48:03.000000000 -0700
+++ libpst64-060926/lspst.c	2006-09-26 14:09:55.000000000 -0600
@@ -37,6 +37,7 @@
 char *rfc2426_escape(char *str);
 char *rfc2445_datetime_format(FILETIME *ft);
 // }}}1
+#undef DEBUG_MAIN
 #define DEBUG_MAIN(x) debug_print x;
 // int main(int argc, char** argv) {{{1
 int main(int argc, char** argv) {
diff -Naur ../orig/libpst-0.5.1/Makefile libpst64-060926/Makefile
--- ../orig/libpst-0.5.1/Makefile	2004-11-17 09:16:02.000000000 -0700
+++ libpst64-060926/Makefile	2006-09-26 14:09:55.000000000 -0600
@@ -1,9 +1,12 @@
 #!/usr/bin/make -f
 
-CFLAGS  ?= -g -Wall
+CFLAGS  ?= -g -Wall 
 PREFIX ?= /usr/local
 INSTALL ?= install
 
+# You might need this
+#LDLIBS ?= -liconv
+
 #---------------- Do not modify below this point ------------------
 
 INSTALL_DIR     := $(INSTALL) -p -d -o root -g root -m 0755
@@ -39,9 +42,11 @@
 readpstlog.o: XGetopt.h define.h
 testdebug.o: define.h
 timeconv.o: timeconv.h common.h
+vbuf.o: vbuf.h
+generic.o: generic.h
 
-readpst: readpst.o libpst.o timeconv.o libstrfunc.o debug.o lzfu.o
-lspst: debug.o libpst.o libstrfunc.o lspst.o timeconv.o
+readpst: readpst.o libpst.o timeconv.o libstrfunc.o debug.o lzfu.o vbuf.o generic.o
+lspst: debug.o libpst.o libstrfunc.o lspst.o timeconv.o vbuf.o generic.o
 getidblock: getidblock.o libpst.o debug.o libstrfunc.o
 testdebug: testdebug.o debug.o
 readpstlog: readpstlog.o debug.o
diff -Naur ../orig/libpst-0.5.1/readpst.c libpst64-060926/readpst.c
--- ../orig/libpst-0.5.1/readpst.c	2004-11-17 07:48:03.000000000 -0700
+++ libpst64-060926/readpst.c	2006-09-26 14:09:55.000000000 -0600
@@ -13,6 +13,8 @@
 #include <limits.h>
 #include <errno.h>
 
+#include "vbuf.h"
+
 #ifndef _WIN32
 # include <unistd.h>
 # include <sys/stat.h> //mkdir
@@ -70,19 +72,19 @@
 // Function Declarations {{{1
 void  write_email_body(FILE *f, char *body);
 char *removeCR (char *c);
-int32_t   usage();
-int32_t   version();
+int   usage();
+int   version();
 char *mk_kmail_dir(char*);
-int32_t   close_kmail_dir();
+int   close_kmail_dir();
 char *mk_recurse_dir(char*);
-int32_t   close_recurse_dir();
+int   close_recurse_dir();
 char *mk_seperate_dir(char *dir, int overwrite);
-int32_t   close_seperate_dir();
-int32_t   mk_seperate_file(struct file_ll *f);
+int   close_seperate_dir();
+int   mk_seperate_file(struct file_ll *f);
 char *my_stristr(char *haystack, char *needle);
 char *check_filename(char *fname);
 char *rfc2426_escape(char *str);
-int32_t chr_count(char *str, char x);
+int chr_count(char *str, char x);
 char *rfc2425_datetime_format(FILETIME *ft);
 char *rfc2445_datetime_format(FILETIME *ft);
 char *skip_header_prologue(char *headers);
@@ -107,6 +109,8 @@
 // saved as email_no-filename (e.g. 1-samplefile.doc or 000001-Attachment2.zip)
 #define MODE_SEPERATE 3
 
+// Decrypt the whole file (even the parts that aren't encrypted) and ralph it to stdout
+#define MODE_DECSPEW 4
 
 // Output Normal just prints the standard information about what is going on
 #define OUTPUT_NORMAL 0
@@ -153,7 +157,7 @@
   prog_name = argv[0];
   // }}}2
 
-  while ((c = getopt(argc, argv, "d:hko:qrSVwc:"))!= -1) {
+  while ((c = getopt(argc, argv, "C6d:hko:qrSVwc:"))!= -1) {
     switch (c) {
     case 'c':
       if (optarg!=NULL && optarg[0]=='v')
@@ -168,6 +172,9 @@
     case 'd':
       d_log = optarg;
       break;
+	case '6':
+	  set_read64();
+	  break;
     case 'h':
       usage();
       exit(0);
@@ -191,6 +198,9 @@
     case 'S':
       mode = MODE_SEPERATE;
       break;
+	case 'C':
+	  mode = MODE_DECSPEW;
+	  break;
     case 'w':
       overwrite = 1;
       break;
@@ -201,6 +211,8 @@
     }
   }
 
+  unicode_init();
+
 #ifdef DEBUG_ALL
   // initialize log file
   if (d_log == NULL)
@@ -218,6 +230,29 @@
     exit(2);
   }
 
+
+  if ( mode == MODE_DECSPEW ) {
+	  FILE *fp;
+	  char buf[1024];
+	  int l=0;
+	  if( NULL == ( fp = fopen(fname, "rb" ) ) ) {
+		  fprintf(stderr, "Couldn't open file %s\n", fname );
+		  return 1;
+	  }
+
+	  while( 0 != ( l = fread( buf, 1, 1024, fp ) ) ) {
+		  if( 0 != _pst_decrypt( buf, l, PST_COMP_ENCRYPT ) ) 
+			  fprintf(stderr, "_pst_decrypt() failed (I'll try to continue)\n");
+
+		  if( l != fwrite( buf, 1, l, stdout ) ) {
+			  fprintf(stderr, "Couldn't output to stdout?\n");
+			  return 1;
+		  }
+	  }
+
+	  return 0;
+  }
+
   if (output_mode != OUTPUT_QUIET) printf("Opening PST file and indexes...\n");
 
   DEBUG_MAIN(("main: Opening PST file '%s'\n", fname));
@@ -1139,6 +1174,8 @@
   printf("\t-S\t- Seperate. Write emails in the seperate format\n");
   printf("\t-V\t- Version. Display program version\n");
   printf("\t-w\t- Overwrite any output mbox files\n");
+  printf("\t-6\t- Attempt to read 64-bit Outlook file (Outlook 2003)\n");
+  printf("\t-C\t- Decrypt the entire file and output on stdout (not typically useful)\n");
   DEBUG_RET();
   return 0;
 }
diff -Naur ../orig/libpst-0.5.1/vbuf.c libpst64-060926/vbuf.c
--- ../orig/libpst-0.5.1/vbuf.c	1969-12-31 17:00:00.000000000 -0700
+++ libpst64-060926/vbuf.c	2006-09-26 14:09:55.000000000 -0600
@@ -0,0 +1,932 @@
+// {{{ includes
+
+#include <ctype.h>
+//#include "defines.h"
+#include <errno.h>
+#include <iconv.h>
+#include <malloc.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "vbuf.h"
+#include "generic.h"
+
+#ifdef WITH_DMALLOC
+#include <dmalloc.h>
+#endif
+
+// }}}
+
+int skip_nl( char *s ) // {{{ returns the width of the newline at s[0]
+{
+        if( s[0] == '\n' ) return 1;
+        if( s[0] == '\r' && s[1] == '\n' ) return 2;
+        if( s[0] == '\0' ) return 0;
+        return -1;
+} // }}}
+int find_nl( vstr *vs ) // {{{ find newline of type type in b
+{
+        char *nextr, *nextn;
+
+        nextr = memchr( vs->b, '\r', vs->dlen );
+        nextn = memchr( vs->b, '\n', vs->dlen );
+
+        //case 1: UNIX, we find \n first
+        if( nextn && (nextr == NULL || nextr > nextn ) ) {
+                return nextn - vs->b;
+        }
+
+        //case 2: DOS, we find \r\n
+        if( NULL != nextr && NULL != nextn && 1 == (char*)nextn - (char*)nextr ) {
+                return nextr - vs->b;
+        }
+
+        //case 3: we find nothing
+
+        return -1;
+} // }}}
+
+// {{{ UTF8 <-> UTF16 <-> ISO8859 Character set conversion functions and (ack) their globals
+
+//TODO: the following should not be
+char *wwbuf=NULL;
+size_t nwwbuf=0;
+static int unicode_up=0;
+iconv_t i16to8, i8to16, i8859_1to8, i8toi8859_1;
+
+void unicode_init() // {{{
+{
+	char *wipe = "";
+	char dump[4];
+
+	if( unicode_up ) unicode_close();
+
+	if( (iconv_t)-1 == (i16to8 = iconv_open( "UTF-8", "UTF-16" ) ) ) {
+		fprintf(stderr, "doexport(): Couldn't open iconv descriptor for UTF-16 to UTF-8.\n");
+		exit( 1 );
+	}
+
+	if( (iconv_t)-1 == (i8to16 = iconv_open( "UTF-16", "UTF-8" ) ) ) {
+		fprintf(stderr, "doexport(): Couldn't open iconv descriptor for UTF-8 to UTF-16.\n");
+		exit( 2 );
+	}
+
+	//iconv will prefix output with an FF FE (utf-16 start seq), the following dumps that.
+	memset( dump, 'x', 4 );
+	ASSERT( 0 == utf8to16( wipe, 1, dump, 4 ), "unicode_init(): attempt to dump FF FE failed." );
+
+	if( (iconv_t)-1 == (i8859_1to8 = iconv_open( "UTF-8", "ISO_8859-1" ) ) ) {
+		fprintf(stderr, "doexport(): Couldn't open iconv descriptor for ASCII to UTF-8.\n");
+		exit( 1 );
+	}
+
+
+	if( (iconv_t)-1 == (i8toi8859_1 = iconv_open( "ISO_8859-1", "UTF-8" ) ) ) {
+		fprintf(stderr, "doexport(): Couldn't open iconv descriptor for UTF-8 to ASCII.\n");
+		exit( 1 );
+	}
+
+	unicode_up = 1;
+}
+// }}}
+void unicode_close() // {{{
+{
+	unicode_up = 0;
+	iconv_close( i8to16 );
+	iconv_close( i16to8 );
+	iconv_close( i8859_1to8 );
+	iconv_close( i8toi8859_1 );
+}
+// }}}
+
+//int utf16_write( FILE* stream, const void *buf, size_t count ) // {{{ write utf-8 or iso_8869-1 to stream after converting it to utf-16
+//{
+//
+//	//TODO: if anything big comes through here we are sunk, should do it
+//	//bit-by-bit, not one-big-gulp
+//	
+//	size_t inbytesleft, outbytesleft;
+//	char *inbuf, *outbuf;
+//	size_t icresult;
+//	size_t rl;
+//
+//	//do we have enough buffer space?
+//	if( !wwbuf || nwwbuf < (count * 2 + 2) ) {
+//		wwbuf = F_REALLOC( wwbuf, count * 2 +2 ); 
+//
+//		nwwbuf = count * 2 + 2;
+//	}
+//
+//	inbytesleft = count; outbytesleft = nwwbuf;
+//	inbuf = (char*)buf; outbuf = wwbuf;
+//
+////	fprintf(stderr, "X%s, %dX", (char*)buf, strlen( buf ));
+////	fflush(stderr);
+//
+//	if( (rl = strlen( buf ) + 1) != count ) {
+//		fprintf(stderr, "utf16_write(): reported buffer size (%d) does not match string length (%d)\n",
+//				count,
+//				rl);
+//
+//		//hexdump( (char*)buf, 0, count, 1 );
+//
+//		raise( SIGSEGV );
+//		inbytesleft = rl;
+//	}
+//
+////	fprintf(stderr, "  attempting to convert:\n");
+////	hexdump( (char*)inbuf, 0, count, 1 );
+//
+//	icresult = iconv( i8to16, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
+//
+////	fprintf(stderr, "  converted:\n");
+////	hexdump( (char*)buf, 0, count, 1 );
+//
+////	fprintf(stderr, "  to:\n");
+////	hexdump( (char*)wwbuf, 0, nwwbuf, 1 );
+//
+//	if( (size_t)-1  == icresult ) {
+//		fprintf(stderr, "utf16_write(): iconv failure(%d): %s\n", errno, strerror( errno ) );
+//		fprintf(stderr, "  attempted to convert:\n");
+//		hexdump( (char*)inbuf, 0, count, 1 );
+//
+//		fprintf(stderr, "  result:\n");
+//		hexdump( (char*)outbuf, 0, count, 1 );
+//
+//		fprintf(stderr, "I'm going to segfault now.\n");
+//		raise( SIGSEGV );
+//		exit(1);
+//	}
+//
+//	if( inbytesleft > 0 ) {
+//		fprintf(stderr, "utf16_write(): iconv returned a short count.\n");
+//		exit(1);
+//	}
+//
+//	return fwrite( wwbuf, nwwbuf - outbytesleft - 2, 1, stream  );
+//}
+// }}}
+
+//char *utf16buf = NULL;
+//int utf16buf_len = 0;
+//
+//int utf16_fprintf( FILE* stream, const char *fmt, ... ) // {{{
+//{
+//	int result=0;
+//	va_list ap;
+//
+//	if( utf16buf == NULL ) {
+//		utf16buf = (char*)F_MALLOC( SZ_MAX + 1 );
+//
+//		utf16buf_len = SZ_MAX + 1;
+//	}
+//
+//	va_start( ap, fmt );
+//
+//	result = vsnprintf( utf16buf, utf16buf_len, fmt, ap );
+//
+//	if( result + 1 > utf16buf_len ) { //didn't have space, realloc() and try again
+//		fprintf(stderr, "utf16_fprintf(): buffer too small (%d), F_MALLOC(%d)\n", utf16buf_len, result);
+//		free( utf16buf );
+//		utf16buf_len = result + 1;
+//		utf16buf = (char*)F_MALLOC( utf16buf_len );
+//
+//		result = vsnprintf( utf16buf, utf16buf_len, fmt, ap );
+//	}
+//
+//
+//	//didn't have space...again...something weird is going on...
+//	ASSERT( result + 1 <= utf16buf_len,  "utf16_fprintf(): Unpossible error!\n");
+//
+//	if( 1 != utf16_write( stream, utf16buf, result + 1 ) )
+//		DIE( "Write error?  -> %s or %s\n", strerror( errno ), uerr_str( uerr_get() ) );
+//
+//	return result;
+//}
+//// }}}
+//int utf16to8( char *inbuf_o, char *outbuf_o, int length ) // {{{
+//{
+//	int inbytesleft = length;
+//	int outbytesleft = length;
+//	char *inbuf = inbuf_o;
+//	char *outbuf = outbuf_o;
+//	int rlen = -1, tlen;
+//	int icresult = -1; 
+//
+//	int i, strlen=-1;
+//	
+//	DEBUG(
+//		fprintf(stderr, "  utf16to8(): attempting to convert:\n");
+//		//hexdump( (char*)inbuf_o, 0, length, 1 );
+//		fflush(stderr);
+//	);
+//
+//	for( i=0; i<length ; i+=2 ) {
+//		if( inbuf_o[i] == 0 && inbuf_o[i + 1] == 0 ) {
+//			//fprintf(stderr, "End of string found at: %d\n", i );
+//			strlen = i;
+//		}
+//	}
+//
+//	//hexdump( (char*)inbuf_o, 0, strlen, 1 );
+//
+//	if( -1 == strlen ) WARN("String is not zero-terminated.");
+//
+//	//iconv does not like it when the inbytesleft > actual string length
+//	//enum: zero terminated, length valid
+//	//      zero terminated, length short //we won't go beyond length ever, so this is same as NZT case
+//	//      zero terminated, length long
+//	//      not zero terminated
+//	//      TODO: MEMORY BUG HERE!
+//	for( tlen = 0; tlen <= inbytesleft - 2; tlen+=2 ) {
+//		if( inbuf_o[tlen] == 0 && inbuf_o[tlen+1] == 0 ){
+//			rlen = tlen + 2;
+//			tlen = rlen;
+//			break;
+//		}
+//		if( tlen == inbytesleft )fprintf(stderr, "Space allocated for string > actual string length.  Go windows!\n");
+//	}
+//
+//	if( rlen >= 0 )
+//		icresult = iconv( i16to8, &inbuf, &rlen, &outbuf, &outbytesleft );
+//
+//	if( icresult == (size_t)-1 ) {
+//		fprintf(stderr, "utf16to8(): iconv failure(%d): %s\n", errno, strerror( errno ) );
+//		fprintf(stderr, "  attempted to convert:\n");
+//		hexdump( (char*)inbuf_o, 0, length, 1 );
+//		fprintf(stderr, "  result:\n");
+//		hexdump( (char*)outbuf_o, 0, length, 1 );
+//		fprintf(stderr, "  MyDirtyOut:\n");
+//		for( i=0; i<length; i++) {
+//			if( inbuf_o[i] != '\0' ) fprintf(stderr, "%c", inbuf_o[i] );
+//		}
+//
+//		fprintf( stderr, "\n" );
+//		raise( SIGSEGV );
+//		exit(1);
+//	}
+//
+//	DEBUG(
+//		fprintf(stderr, "  result:\n");
+//		hexdump( (char*)outbuf_o, 0, length, 1 );
+//	     )
+//
+//	//fprintf(stderr, "utf16to8() returning %s\n", outbuf );
+//
+//	return icresult;	
+//}
+//// }}}
+int utf16_is_terminated( char *str, int length ) // {{{
+{
+	VSTR_STATIC( errbuf, 100 );
+	int len = -1;
+	int i;
+	for( i=0; i<length ; i+=2 ) {
+		if( str[i] == 0 && str[i + 1] == 0 ) {
+			//fprintf(stderr, "End of string found at: %d\n", i );
+			len = i;
+		}
+	}
+
+	//hexdump( (char*)inbuf_o, 0, len, 1 );
+
+	if( -1 == len ) {
+		vshexdump( errbuf, str, 0, length, 1 );
+		WARN("String is not zero terminated (probably broken data from registry) %s.", errbuf->b);
+	}
+
+	return (-1 == len )?0:1;
+} // }}}
+int vb_utf16to8( vbuf *dest, char *buf, int len ) // {{{
+{
+	int inbytesleft = len;
+	char *inbuf = buf;
+	//int rlen = -1, tlen;
+	int icresult = -1; 
+	VBUF_STATIC( dumpster, 100 );
+
+	//int i; //, strlen=-1;
+	int outbytesleft; 
+	char *outbuf;
+
+	ASSERT( unicode_up, "vb_utf16to8() called before unicode started." );
+
+	if( 2 > dest->blen ) vbresize( dest, 2 );
+	dest->dlen = 0;
+
+	//Bad Things can happen if a non-zero-terminated utf16 string comes through here
+	if( !utf16_is_terminated( buf, len ) ) return -1;
+
+	do {
+		outbytesleft = dest->blen - dest->dlen;
+		outbuf = dest->b + dest->dlen;
+		icresult = iconv( i16to8, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
+		dest->dlen = outbuf - dest->b;
+		vbgrow( dest, inbytesleft);
+	} while( (size_t)-1 == icresult && E2BIG == errno );
+
+	if( 0 != vb_utf8to16T( dumpster, dest->b, dest->dlen ) )
+		DIE("Reverse conversion failed.");
+
+	if( icresult == (size_t)-1 ) {
+		//TODO: error
+		//ERR_UNIX( errno, "vb_utf16to8():iconv failure: %s", strerror( errno ) );
+		unicode_init();
+		return -1;
+		/*
+		fprintf(stderr, "  attempted to convert:\n");
+		hexdump( (char*)cin, 0, inlen, 1 );
+		fprintf(stderr, "  result:\n");
+		hexdump( (char*)bout->b, 0, bout->dlen, 1 );
+		fprintf(stderr, "  MyDirtyOut:\n");
+		for( i=0; i<inlen; i++) {
+			if( inbuf[i] != '\0' ) fprintf(stderr, "%c", inbuf[i] );
+		}
+
+		fprintf( stderr, "\n" );
+		raise( SIGSEGV );
+		exit(1);
+		*/
+	}
+
+	if( icresult ) {
+		//ERR_UNIX( EILSEQ, "Uhhhh...vb_utf16to8() returning icresult == %d", icresult );
+		return -1;
+	}
+	return icresult;	
+}
+// }}}
+
+int utf8to16( char *inbuf_o, int iblen, char *outbuf_o, int oblen) // {{{ iblen, oblen: bytes including \0
+{
+	//TODO: this is *only* used to dump the utf16 preamble now...
+	//TODO: This (and 8to16) are the most horrible things I have ever seen...
+	int inbytesleft;
+	int outbytesleft = oblen;
+	char *inbuf = inbuf_o;
+	char *outbuf = outbuf_o;
+	//int rlen = -1, tlen;
+	int icresult = -1; 
+
+	char *stend;
+
+	//int i; //, strlen=-1;
+	
+	DEBUG(
+		fprintf(stderr, "  utf8to16(): attempting to convert:\n");
+		//hexdump( (char*)inbuf_o, 0, length, 1 );
+		fflush(stderr);
+	);
+
+	stend = memchr( inbuf_o, '\0', iblen );
+	ASSERT( NULL != stend, "utf8to16(): in string not zero terminated." );
+
+	inbytesleft = ( stend - inbuf_o + 1 < iblen )? stend - inbuf_o + 1: iblen;
+
+	//iconv does not like it when the inbytesleft > actual string length
+	//enum: zero terminated, length valid
+	//      zero terminated, length short //we won't go beyond length ever, so this is same as NZT case
+	//      zero terminated, length long
+	//      not zero terminated
+	//      TODO: MEMORY BUG HERE!
+	//      
+	/*
+	for( tlen = 0; tlen <= inbytesleft - 2; tlen+=2 ) {
+		if( inbuf_o[tlen] == 0 && inbuf_o[tlen+1] == 0 ){
+			rlen = tlen + 2;
+			tlen = rlen;
+			break;
+		}
+		if( tlen == inbytesleft )fprintf(stderr, "Space allocated for string > actual string length.  Go windows!\n");
+	}
+	*/
+
+	//if( rlen >= 0 )
+		icresult = iconv( i8to16, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
+
+	if( icresult == (size_t)-1 ) {
+		DIE("iconv failure(%d): %s\n", errno, strerror( errno ) );
+		//fprintf(stderr, "  attempted to convert:\n");
+		//hexdump( (char*)inbuf_o, 0, iblen, 1 );
+		//fprintf(stderr, "  result:\n");
+		//hexdump( (char*)outbuf_o, 0, oblen, 1 );
+		//fprintf(stderr, "  MyDirtyOut:\n");
+//		for( i=0; i<iblen; i++) {
+//			if( inbuf_o[i] != '\0' ) fprintf(stderr, "%c", inbuf_o[i] );
+//		}
+//
+//		fprintf( stderr, "\n" );
+//		raise( SIGSEGV );
+//		exit(1);
+	}
+
+//	DEBUG(
+//		fprintf(stderr, "  result:\n");
+//		hexdump( (char*)outbuf_o, 0, oblen, 1 );
+//	     )
+
+	//fprintf(stderr, "utf8to16() returning %s\n", outbuf );
+
+	//TODO: error
+	if( icresult ) printf("Uhhhh...utf8to16() returning icresult == %d\n", icresult );
+	return icresult;	
+}
+// }}}
+
+int vb_utf8to16T( vbuf *bout, char *cin, int inlen ) // {{{ 
+{
+	//TODO: This (and 8to16) are the most horrible things I have ever seen...
+	int inbytesleft = inlen;
+	char *inbuf = cin;
+	//int rlen = -1, tlen;
+	int icresult = -1; 
+
+	//int i; //, strlen=-1;
+	
+	//if( rlen >= 0 )
+	int outbytesleft; 
+	char *outbuf;
+	if( 2 > bout->blen ) vbresize( bout, 2 );
+	bout->dlen = 0;
+
+	do {
+		outbytesleft = bout->blen - bout->dlen;
+		outbuf = bout->b + bout->dlen;
+		icresult = iconv( i8to16, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
+		bout->dlen = outbuf - bout->b;
+		vbgrow( bout, 20 );
+	} while( (size_t)-1 == icresult && E2BIG == errno );
+
+	if( icresult == (size_t)-1 ) {
+		WARN("iconv failure: %s", strerror( errno ) );
+		//ERR_UNIX( errno, "vb_utf8to16():iconv failure: %s", strerror( errno ) );
+		unicode_init();
+		return -1;
+		/*
+		fprintf(stderr, "vb_utf8to16(): iconv failure(%d == %d?): %s\n", errno, E2BIG, strerror( errno ) );
+		fprintf(stderr, "  attempted to convert:\n");
+		hexdump( (char*)cin, 0, inlen, 1 );
+		fprintf(stderr, "  result:\n");
+		hexdump( (char*)bout->b, 0, bout->dlen, 1 );
+		fprintf(stderr, "  MyDirtyOut:\n");
+		for( i=0; i<inlen; i++) {
+			if( inbuf[i] != '\0' ) fprintf(stderr, "%c", inbuf[i] );
+		}
+
+		fprintf( stderr, "\n" );
+		raise( SIGSEGV );
+		exit(1);
+		*/
+	}
+
+	//TODO: error
+	if( icresult ) printf("Uhhhh...vb_utf8to16() returning icresult == %d\n", icresult );
+	return icresult;	
+}
+// }}}
+#if 1
+void cheap_uni2ascii(char *src, char *dest, int l) /* {{{ Quick and dirty UNICODE to std. ascii */
+{
+
+	for (; l > 0; l -=2) {
+		*dest = *src;
+		dest++; src +=2;
+	}
+	*dest = 0;
+}
+// }}}
+#endif
+
+void cheap_ascii2uni(char *src, char *dest, int l) /* {{{ Quick and dirty ascii to unicode */
+{
+   for (; l > 0; l--) {
+      *dest++ = *src++;
+      *dest++ = 0;
+
+   }
+}
+// }}}
+
+// }}}
+// {{{ VARBUF Functions 
+vbuf *vballoc( size_t len ) // {{{
+{
+	struct varbuf *result;
+
+	result = F_MALLOC( sizeof( struct varbuf ) );
+
+	result->dlen = 0;
+	result->blen = 0;
+	result->buf = NULL;
+
+	vbresize( result, len );
+
+	return result;
+
+} // }}}
+void vbcheck( vbuf *vb ) // {{{
+{
+	ASSERT( vb->b - vb->buf <= vb->blen, "vbcheck(): vb->b outside of buffer range.");
+	ASSERT( vb->dlen <= vb->blen, "vbcheck(): data length > buffer length.");
+
+	ASSERT( vb->blen < 1024*1024, "vbcheck(): blen is a bit large...hmmm.");
+} // }}}
+void vbfree( vbuf *vb ) // {{{
+{
+	free( vb->buf );
+	free( vb );
+} // }}}
+void vbclear( struct varbuf *vb ) // {{{ditch the data, keep the buffer
+{
+	vbresize( vb, 0 );
+} // }}}
+void vbresize( struct varbuf *vb, size_t len ) // {{{ DESTRUCTIVELY grow or shrink buffer
+{
+	vb->dlen = 0;
+
+	if( vb->blen >= len ) {
+		vb->b = vb->buf;
+		return;
+	}
+
+	vb->buf = F_REALLOC( vb->buf, len );
+	vb->b = vb->buf;
+	vb->blen = len;
+} // }}}
+int vbavail( vbuf *vb ) // {{{
+{
+	return vb->blen - ((char*)vb->b - (char*)vb->buf + vb->dlen);
+} // }}}
+//void vbdump( vbuf *vb ) // {{{ TODO: to stdout?  Yuck
+//{
+//	printf("vb dump-------------\n");
+//        printf("dlen: %d\n", vb->dlen );
+//	printf("blen: %d\n", vb->blen );
+//	printf("b - buf: %d\n", vb->b - vb->buf );
+//	printf("buf:\n");
+//	hexdump( vb->buf, 0, vb->blen, 1 );
+//	printf("b:\n");
+//	hexdump( vb->b, 0, vb->dlen, 1 );
+//	printf("^^^^^^^^^^^^^^^^^^^^\n");
+//} // }}}
+void vbgrow( struct varbuf *vb, size_t len ) // {{{ out: vbavail(vb) >= len, data are preserved
+{
+	if( 0 == len ) return;
+
+	if( 0 == vb->blen ) {
+		vbresize( vb, len );
+		return;
+	}
+
+	if( vb->dlen + len > vb->blen ) {
+		if( vb->dlen + len < vb->blen * 1.5 ) len = vb->blen * 1.5;
+		char *nb = F_MALLOC( vb->blen + len );
+		//printf("vbgrow() got %p back from malloc(%d)\n", nb, vb->blen + len);
+		vb->blen = vb->blen + len;
+		memcpy( nb, vb->b, vb->dlen );
+
+		//printf("vbgrow() I am going to free %p\n", vb->buf );
+		free( vb->buf );
+		vb->buf = nb;
+		vb->b = vb->buf;
+	} else {
+		if( vb->b != vb->buf ) 
+			memcpy( vb->buf, vb->b, vb->dlen );
+	}
+
+	vb->b = vb->buf;
+
+	ASSERT( vbavail( vb ) >= len, "vbgrow(): I have failed in my mission." );
+} // }}}
+void vbset( vbuf *vb, void *b, size_t len ) // {{{ set vbuf b size=len, resize if necessary, relen = how much to over-allocate
+{
+	vbresize( vb, len );
+
+	memcpy( vb->b, b, len );
+	vb->dlen = len;
+} // }}}
+void vsskipws( vstr *vs ) // {{{
+{
+	char *p = vs->b;
+	while( p - vs->b < vs->dlen && isspace( p[0] ) ) p++;
+
+	vbskip( (vbuf*)vs, p - vs->b );
+} // }}}
+void vbappend( struct varbuf *vb, void *b, size_t len ) // {{{ append len bytes of b to vbuf, resize if necessary
+{
+	if( 0 == vb->dlen ) {
+		vbset( vb, b, len );
+		return;
+	}
+
+	vbgrow( vb, len );
+
+	memcpy( vb->b + vb->dlen, b, len );
+	vb->dlen += len;
+
+	//printf("vbappend() end: >%s/%d<\n", vbuf->b, vbuf->dlen );
+} // }}}
+void vbskip( struct varbuf *vb, size_t skip ) // {{{ dumps the first skip bytes from vbuf
+{
+	ASSERT( skip <= vb->dlen, "vbskip(): Attempt to seek past end of buffer." );
+	//memmove( vbuf->b, vbuf->b + skip, vbuf->dlen - skip );
+	vb->b += skip;
+	vb->dlen -= skip;
+} // }}}
+void vboverwrite( struct varbuf *vbdest, struct varbuf *vbsrc ) // {{{ overwrite vbdest with vbsrc
+{
+	vbresize( vbdest, vbsrc->blen );
+	memcpy( vbdest->b, vbsrc->b, vbsrc->dlen );
+	vbdest->blen = vbsrc->blen;
+	vbdest->dlen = vbsrc->dlen;
+} // }}}
+// }}}
+// {{{ VARSTR Functions
+vstr *vsalloc( size_t len ) // {{{
+{
+	vstr *result = (vstr*)vballoc( len + 1 );
+	vsset( result, "" );
+	return result;
+} // }}}
+char *vsstr( vstr *vs ) // {{{
+{
+	return vs->b;
+} // }}}
+size_t vslen( vstr *vs ) // {{{
+{
+	return strlen( vsstr( vs ));
+} // }}}
+void vsfree( vstr *vs ) // {{{
+{
+	vbfree( (vbuf*)vs );
+} // }}}
+void vscharcat( vstr *vb, int ch ) // {{{
+{
+	vbgrow( (vbuf*)vb, 1);
+	vb->b[vb->dlen-1] = ch;
+	vb->b[vb->dlen] = '\0';
+	vb->dlen++;
+} // }}}
+void vsnprepend( vstr *vb, char *str, size_t len ) // {{{ prependappend string str to vbuf, vbuf must already contain a valid string 
+{
+	ASSERT( vb->b[vb->dlen-1] == '\0', "vsncat(): attempt to append string to non-string.");
+	int sl = strlen( str );
+	int n = (sl<len)?sl:len;
+	//string append
+	vbgrow( (vbuf*)vb, n + 1 );
+	memmove( vb->b + n, vb->b, vb->dlen - 1 );
+	memcpy( vb->b, str, n );
+	//strncat( vb->b, str, n );
+
+	vb->dlen += n;
+	vb->b[ vb->dlen - 1 ] = '\0';
+} // }}}
+void vsskip( vstr *vs, size_t len ) // {{{ len < dlen-1 -> skip len chars, else DIE
+{
+	ASSERT( len < vs->dlen - 1, "Attempt to skip past end of string" );
+	vbskip( (vbuf*)vs, len );
+} // }}}
+int vsskipline( vstr *vs ) // {{{ in: vb->b == "stuff\nmore_stuff"; out: vb->b == "more_stuff"
+{
+	int nloff = find_nl( vs );
+	int nll = skip_nl( vs->b + nloff );
+
+	if( nloff < 0 ) {
+		//TODO: error
+		printf("vb_skipline(): there seems to be no newline here.\n");
+		return -1;
+	}
+	if( skip_nl < 0 ) {
+		//TODO: error
+		printf("vb_skipline(): there seems to be no newline here...except there should be. :P\n");
+		return -1;
+	}
+
+	memmove( vs->b, vs->b + nloff + nll, vs->dlen - nloff - nll );
+
+	vs->dlen -= nloff + nll;
+
+	return 0;
+} // }}}
+int vscatprintf( vstr *vs, char *fmt, ... ) // {{{
+{
+	int size;
+	va_list ap;
+
+	/* Guess we need no more than 100 bytes. */
+	//vsresize( vb, 100 );
+	if(!vs->b || vs->dlen == 0) {
+		vsset( vs, "" );
+	}
+
+	while (1) {
+		/* Try to print in the allocated space. */
+		va_start(ap, fmt);
+		size = vsnprintf (vs->b + vs->dlen - 1, vs->blen - vs->dlen, fmt, ap);
+		va_end(ap);
+
+		/* If that worked, return the string. */
+		if (size > -1 && size < vs->blen - vs->dlen ) {
+			vs->dlen += size;
+			return size;
+		}
+		/* Else try again with more space. */
+		if ( size >= 0 )    /* glibc 2.1 */
+			vbgrow( (vbuf*)vs, size+1 ); /* precisely what is needed */
+		else           /* glibc 2.0 */
+			vbgrow( (vbuf*)vs, vs->blen);
+	}
+} // }}}
+int vslast( vstr *vs ) // {{{ returns the last character stored in a vstr 
+{
+	if( vs->dlen < 1 ) return -1;
+	if( vs->b[vs->dlen-1] != '\0' ) return -1;
+	if( vs->dlen == 1 ) return '\0';
+	return vs->b[vs->dlen-2];
+} // }}}
+void vs_printf( vstr *vs, char *fmt, ... ) // {{{ print over vb
+{
+	int size;
+	va_list ap;
+
+	/* Guess we need no more than 100 bytes. */
+	vbresize( (vbuf*)vs, 100 );
+
+	while (1) {
+		/* Try to print in the allocated space. */
+		va_start(ap, fmt);
+		size = vsnprintf (vs->b, vs->blen, fmt, ap);
+		va_end(ap);
+
+		/* If that worked, return the string. */
+		if (size > -1 && size < vs->blen) {
+			vs->dlen = size + 1;
+			return;
+		}
+		/* Else try again with more space. */
+		if ( size >= 0 )    /* glibc 2.1 */
+			vbresize( (vbuf*)vs, size+1 ); /* precisely what is needed */
+		else           /* glibc 2.0 */
+			vbresize( (vbuf*)vs, vs->blen*2);
+	}
+} // }}}
+void vs_printfa( vstr *vs, char *fmt, ... ) // {{{ printf append to vs
+{
+	int size;
+	va_list ap;
+
+	if( vs->blen - vs->dlen < 50 )
+		vbgrow( (vbuf*)vs, 100 );
+
+	while (1) {
+		/* Try to print in the allocated space. */
+		va_start(ap, fmt);
+		size = vsnprintf (vs->b + vs->dlen - 1, vs->blen - vs->dlen + 1, fmt, ap);
+		va_end(ap);
+
+		/* If that worked, return the string. */
+		if (size > -1 && size < vs->blen) {
+			vs->dlen += size;
+			return;
+		}
+		/* Else try again with more space. */
+		if ( size >= 0 )    /* glibc 2.1 */
+			vbgrow( (vbuf*)vs, size+1 - vs->dlen ); /* precisely what is needed */
+		else           /* glibc 2.0 */
+			vbgrow( (vbuf*)vs, size );
+	}
+} // }}}
+void vshexdump( vstr *vs, char *b, size_t start, size_t stop, int ascii ) // {{{
+{
+	char c;
+	int diff,i;
+
+	while (start < stop ) {
+		diff = stop - start;
+		if (diff > 16) diff = 16;
+
+		vs_printfa(vs, ":%08X  ",start);
+
+		for (i = 0; i < diff; i++) {
+			if( 8 == i ) vs_printfa( vs, " " );
+			vs_printfa(vs, "%02X ",(unsigned char)*(b+start+i));
+		}
+		if (ascii) {
+			for (i = diff; i < 16; i++) vs_printfa(vs, "   ");
+			for (i = 0; i < diff; i++) {
+				c = *(b+start+i);
+				vs_printfa(vs, "%c", isprint(c) ? c : '.');
+			}
+		}
+		vs_printfa(vs, "\n");
+		start += 16;
+	}
+} // }}}
+void vsset( vstr *vs, char *s ) // {{{ Store string s in vs
+{
+	vsnset( vs, s, strlen( s ) );
+} // }}}
+void vsnset( vstr *vs, char *s, size_t n ) // {{{ Store string s in vs
+{
+	vbresize( (vbuf*)vs, n + 1 );
+	memcpy( vs->b, s, n);
+	vs->b[n] = '\0';
+	vs->dlen = n+1;
+} // }}}
+void vsgrow(      vstr *vs, size_t len ) // {{{ grow buffer by len bytes, data are preserved
+{
+	vbgrow( (vbuf*)vs, len );
+} // }}}
+size_t vsavail( vstr *vs ) // {{{
+{
+	return vbavail( (vbuf*)vs );
+} // }}}
+void vsnset16( vstr *vs, char *s, size_t len ) // {{{ Like vbstrnset, but for UTF16
+{
+	vbresize( (vbuf*)vs, len+1 );
+	memcpy( vs->b, s, len );
+	
+	vs->b[len] = '\0';
+	vs->dlen = len+1;
+	vs->b[len] = '\0';
+} // }}}
+void vscat( vstr *vs, char *str ) // {{{
+{
+	vsncat( vs, str, strlen(str ) );
+} // }}}
+int vscmp( vstr *vs, char *str ) // {{{
+{
+	return strcmp( vs->b, str );
+} // }}}
+void vsncat( vstr *vs, char *str, size_t len ) // {{{ append string str to vstr, vstr must already contain a valid string 
+{
+	ASSERT( vs->b[vs->dlen-1] == '\0', "vsncat(): attempt to append string to non-string.");
+	int sl = strlen( str );
+	int n = (sl<len)?sl:len;
+	//string append
+	vbgrow( (vbuf*)vs, n + 1 );
+	memcpy( vs->b + vs->dlen - 1, str, n );
+	//strncat( vs->b, str, n );
+
+	vs->dlen += n;
+	vs->b[ vs->dlen - 1 ] = '\0';
+} // }}}
+void vstrunc( vstr *v, int off ) // {{{ Drop chars [off..dlen] 
+{
+	if( off >= v->dlen - 1 ) return; //nothing to do
+	v->b[off] = '\0';
+	v->dlen = off + 1;
+}
+// }}}
+// }}}
+// {{{ User input
+// TODO: not sure how useful this stuff is here
+int fmyinput(char *prmpt, char *ibuf, int maxlen) /* {{{ get user input */
+{
+	printf("%s",prmpt);
+
+	fgets(ibuf,maxlen+1,stdin);
+
+	ibuf[strlen(ibuf)-1] = 0;
+
+	return(strlen(ibuf));
+}
+// }}}
+//}}}
+//
+//
+//{{{ String formatting and output to FILE *stream or just stdout, etc 
+// TODO: a lot of old, unused stuff in here
+void vswinhex8(vstr *vs, unsigned char *hbuf, int start, int stop, int loff ) // {{{ Produce regedit-style hex output */
+{
+	int i;
+	int lineflag=0;
+
+	for( i=start; i<stop; i++)
+	{
+		loff += vscatprintf( vs, "%02x", hbuf[i] );
+		if( i < stop - 1 ) {
+			loff+=vscatprintf( vs, "," );
+			switch( lineflag ) {
+				case 0:
+				if( loff >= 77) {
+					lineflag=1;
+					loff=0;
+					vscatprintf( vs, "\\%s  ", STUPID_CR );
+				}
+				break;
+				case 1:
+				if( loff >= 75 ) {
+					loff=0;
+					vscatprintf( vs, "\\%s  ", STUPID_CR );
+				}
+				break;
+			}
+			//	if( 24 < i || 0 == (i - 17) % 25 ) fprintf( stream, "\\\n  " );
+		}
+	}
+
+	//   fprintf( stream, "\n" );
+} // }}}
diff -Naur ../orig/libpst-0.5.1/vbuf.h libpst64-060926/vbuf.h
--- ../orig/libpst-0.5.1/vbuf.h	1969-12-31 17:00:00.000000000 -0700
+++ libpst64-060926/vbuf.h	2006-09-26 14:09:55.000000000 -0600
@@ -0,0 +1,142 @@
+/* {{{ vbuf.h - variable length buffer functions
+ *
+ * Functions that try to make dealing with buffers easier.
+ *
+ * vbuf
+ *
+ * vstr
+ * - should always contain a valid string
+ *
+ * }}} */
+
+#ifndef VBUF_H
+#define VBUF_H
+#define SZ_MAX     4096
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+/***************************************************/
+
+// {{{ Tokenizer const TOK_EMPTY, TOK_ELEMENT, DELIM
+#define DELIM '\\'
+
+#define TOK_EMPTY	0
+#define TOK_DELIM	1
+#define TOK_PARENT	2
+#define TOK_CURRENT	3
+#define TOK_ELEMENT	4
+
+#define TOK_ERROR	10
+#define TOK_BUF_SMALL	11
+// }}}
+
+
+// Variable-length buffers 
+struct varbuf { // {{{
+	size_t dlen; 	//length of data stored in buffer
+	size_t blen; 	//length of buffer
+	char *buf; 	//buffer
+	char *b;	//start of stored data
+}; // }}}
+
+
+// The exact same thing as a varbuf but should always contain at least '\0' 
+struct varstr { // {{{
+	size_t dlen; 	//length of data stored in buffer
+	size_t blen; 	//length of buffer
+	char *buf; 	//buffer
+	char *b;	//start of stored data
+}; // }}}
+
+
+typedef struct varbuf vbuf;
+typedef struct varstr vstr;
+
+#define VBUF_STATIC(x,y) static vbuf *x = NULL; if(!x) x = vballoc(y);
+#define VSTR_STATIC(x,y) static vstr *x = NULL; if(!x) x = vsalloc(y);
+
+// vbuf functions
+struct varbuf *vballoc( size_t len );
+void vbfree(      vbuf *vb );
+void vbclear(     vbuf *vb ); //ditch the data, keep the buffer
+void vbresize(    vbuf *vb, size_t len );
+int  vbavail(     vbuf *vb );
+void vbdump(      vbuf *vb );
+void vbgrow(      vbuf *vb, size_t len ); // grow buffer by len bytes, data are preserved
+void vbset(       vbuf *vb, void *data, size_t len );
+void vbskipws(    vbuf *vb ); 
+void vbappend(    vbuf *vb, void *data, size_t length );
+void vbskip(      vbuf *vb, size_t skip ); 
+void vboverwrite( vbuf *vbdest, vbuf *vbsrc );
+
+// vstr functions
+vstr *vsalloc( size_t len );
+char *vsb(      vstr *vs );
+size_t vslen(     vstr *vs ); //strlen
+void vsfree(      vstr *vs );
+void vsset(       vstr *vs, char *s ); // Store string s in vb
+void vsnset(      vstr *vs, char *s, size_t n ); // Store string s in vb
+void vsgrow(      vstr *vs, size_t len ); // grow buffer by len bytes, data are preserved
+size_t vsavail(   vstr *vs );
+void vscat(       vstr *vs, char *str );
+void vsncat(      vstr *vs, char *str, size_t len );
+void vsnprepend(  vstr *vs, char *str, size_t len ) ;
+void vsskip(      vstr *vs, size_t len );
+int  vscmp(       vstr *vs, char *str );
+void vsskipws(    vstr *vs );
+void vs_printf(   vstr *vs, char *fmt, ... );
+void vs_printfa(  vstr *vs, char *fmt, ... );
+void vshexdump(   vstr *vs, char *b, size_t start, size_t stop, int ascii );
+int  vscatprintf( vstr *vs, char *fmt, ... );
+void vsvprintf(   vstr *vs, char *fmt, va_list ap );
+void vstrunc(     vstr *vs, int off ); // Drop chars [off..dlen]
+int  vslast(      vstr *vs ); // returns the last character stored in a vstr string
+void vscharcat(   vstr *vs, int ch );
+int  vsutf16(     vstr *vs, vbuf *in ); //in: in=zero-terminated utf16; out: vs=utf8; returns: 0 on success, else on fail
+
+int vs_parse_escaped_string( vstr *vs, char *str, size_t len );
+
+
+/*
+ * Windows unicode output trash - this stuff sucks
+ * TODO: most of this should not be here
+ */
+
+void unicode_init();
+void unicode_close();
+int utf16_write( FILE* stream, const void *buf, size_t count );
+int utf16_fprintf( FILE* stream, const char *fmt, ... );
+int utf16to8( char *inbuf_o, char *outbuf_o, int length );
+int utf8to16( char *inbuf_o, int iblen, char *outbuf_o, int oblen);
+int vb_utf8to16T( vbuf *bout, char *cin, int inlen );
+int vb_utf16to8( vbuf *dest, char *buf, int len );
+int iso8859_1to8( char *inbuf_o, char *outbuf_o, int length );
+int utf8toascii( const char *inbuf_o, char *outbuf_o, int length );
+
+/* dump ascii hex in windoze format */
+void winhex(FILE* stream, unsigned char *hbuf, int start, int stop, int loff);
+void winhex8(FILE *stream, unsigned char *hbuf, int start, int stop, int loff );
+
+void vbwinhex8(vbuf *vb, unsigned char *hbuf, int start, int stop, int loff );
+
+/* general search routine, find something in something else */
+int find_in_buf(char *buf, char *what, int sz, int len, int start);
+
+/* Get INTEGER from memory. This is probably low-endian specific? */
+int get_int( char *array );
+
+int find_nl( vstr *vs ); // find newline of type type in b
+int skip_nl( char *s ); // returns the width of the newline at s[0]
+//int vb_readline( struct varbuf *vb, int *ctype, FILE *in ); // read *AT LEAST* one full line of data from in
+int vb_skipline( struct varbuf *vb ); // in: vb->b == "stuff\nmore_stuff"; out: vb->b == "more_stuff"
+/* Get a string of HEX bytes (space separated),
+ * or if first char is ' get an ASCII string instead.  */
+int gethexorstr(char **c, char *wb);
+char *esc_index( char *s, int c ); // just like index(3), but works on strings with escape sequences
+char *esc_rindex( char *s, int c ); // just like rindex(3), but works on strings with escape sequences
+
+char *tok_esc_char( char *s, int *is_esc, int *c );
+int vb_path_token( vbuf *tok, char **path ); // returns things like TOK_EMPTY, TOK_ERROR, complete list at top
+
+int gettoken( char *tok, int len, char **path, char delim ); // Path tokenizer: increments path, dumps token in tok
+#endif