Mercurial > libpst
view archive/patch1 @ 328:c507af52515a
add readpst -a option
| author | Carl Byington <carl@five-ten-sg.com> |
|---|---|
| date | Wed, 12 Jun 2013 19:45:44 -0700 |
| parents | de3753c3160a |
| children |
line wrap: on
line source
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