Mercurial > libpst
diff archive/patch1 @ 57:de3753c3160a
add archive directory with history of alioth versions that have been merged here
| author | Carl Byington <carl@five-ten-sg.com> |
|---|---|
| date | Sat, 02 Feb 2008 12:54:07 -0800 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/archive/patch1 Sat Feb 02 12:54:07 2008 -0800 @@ -0,0 +1,2511 @@ +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