Mercurial > libpst

comparison src/libpst.c @ 43:f6db1f060a95

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
start on outlook 2003 64 bit format
author carl
date Sun, 06 Jan 2008 14:47:06 -0800
parents 183ae993b9ad
children d4606d460daf
comparison
equal deleted inserted replaced
42:7a97f50c39c5 43:f6db1f060a95
1 /*** 1 /***
2 * libpst.c 2 * libpst.c
3 * Part of the LibPST project 3 * Part of the LibPST project
4 * Written by David Smith 4 * Written by David Smith
5 * dave.s@earthcorp.com 5 * dave.s@earthcorp.com
6 */ 6 */
7 #include <stdio.h> 7 #include <stdio.h>
8 #include <stdlib.h> 8 #include <stdlib.h>
9 #include <time.h> 9 #include <time.h>
10 #include <string.h> 10 #include <string.h>
11 #include <ctype.h> 11 #include <ctype.h>
12 #include <limits.h> 12 #include <limits.h>
13 #include <wchar.h> 13 #include <wchar.h>
14 14 #include <signal.h>
15 #include <errno.h> 15 #include <errno.h>
16 #include <sys/stat.h> // mkdir 16 #include <sys/stat.h> // mkdir
17 #include <fcntl.h> // for Win32 definition of _O_BINARY 17 #include <fcntl.h> // for Win32 definition of _O_BINARY
18 #include "define.h" 18 #include "define.h"
19 #include "libstrfunc.h" 19 #include "libstrfunc.h"
20 #include "vbuf.h"
21
22 #define ASSERT(x) { if(!(x)) raise( SIGSEGV ); }
20 23
21 #ifdef _MSC_VER 24 #ifdef _MSC_VER
22 # include <windows.h> 25 # include <windows.h>
23 #else 26 #else
24 # include <unistd.h> 27 # include <unistd.h>
25 #endif //ifdef _MSC_VER 28 #endif //ifdef _MSC_VER
26 29
27 #include "libpst.h" 30 #include "libpst.h"
28 #include "timeconv.h" 31 #include "timeconv.h"
29 32 #define INDEX_DEPTH 0x4C
30 #define FILE_SIZE_POINTER 0xA8 33 #define SECOND_DEPTH 0x5C
31 #define INDEX_POINTER 0xC4 34 #define INDEX_TYPE32 0x0E
32 #define SECOND_POINTER 0xBC 35 #define INDEX_TYPE64 0x17
33 // the encryption setting could be at 0x1CC. Will require field testing 36
34 #define ENC_OFFSET 0x1CD 37 #define FILE_SIZE_POINTER32 0xA8
35 // says the type of index we have 38 #define INDEX_POINTER32 0xC4
36 #define INDEX_TYPE_OFFSET 0x0A 39 #define INDEX_COUNT32 0xC0
37 40 #define SECOND_POINTER32 0xBC
38 // for the 64bit 2003 outlook PST we need new file offsets 41 #define SECOND_COUNT32 0xB8
39 // perhaps someone can figure out the header format for the pst files... 42 #define INDEX_TYPE_OFFSET32 0x0A
40 #define FILE_SIZE_POINTER_64 0xB8 43 #define ENC_OFFSET32 0x1CD
41 #define INDEX_POINTER_64 0xF0 44
42 #define SECOND_POINTER_64 0xE0 45 #define FILE_SIZE_POINTER64 0xB8
46 #define INDEX_POINTER64 0xF0
47 #define INDEX_COUNT64 0xE8
48 #define SECOND_POINTER64 0xE0
49 #define SECOND_COUNT64 0xD8
50 #define INDEX_TYPE_OFFSET64 0x0A
51 #define ENC_OFFSET64 0x201
52
53 #define FILE_SIZE_POINTER ((do_read64) ? FILE_SIZE_POINTER64 : FILE_SIZE_POINTER32)
54 #define INDEX_POINTER ((do_read64) ? INDEX_POINTER64 : INDEX_POINTER32)
55 #define INDEX_COUNT ((do_read64) ? INDEX_COUNT64 : INDEX_COUNT32)
56 #define SECOND_POINTER ((do_read64) ? SECOND_POINTER64 : SECOND_POINTER32)
57 #define SECOND_COUNT ((do_read64) ? SECOND_COUNT64 : SECOND_COUNT32)
58 #define INDEX_TYPE_OFFSET ((do_read64) ? INDEX_TYPE_OFFSET64 : INDEX_TYPE_OFFSET32)
59 #define INDEX_TYPE ((do_read64) ? INDEX_TYPE64 : INDEX_TYPE32)
60 #define ENC_OFFSET ((do_read64) ? ENC_OFFSET64 : ENC_OFFSET32)
43 61
44 #define PST_SIGNATURE 0x4E444221 62 #define PST_SIGNATURE 0x4E444221
45 63
46 struct _pst_table_ptr_struct{ 64 int do_read64 = 0; //set this to 1 in order to try and read 64-bit pst files (Outlook 2003)
47 int32_t start; 65
48 int32_t u1; 66 struct _pst_table_ptr_struct32{
49 int32_t offset; 67 int32_t start;
68 int32_t u1;
69 int32_t offset;
50 }; 70 };
71 struct _pst_table_ptr_structn{
72 int64_t start;
73 int64_t u1;
74 int64_t offset;
75 };
51 76
52 typedef struct _pst_block_header { 77 typedef struct _pst_block_header {
53 int16_t type; 78 int16_t type;
54 int16_t count; 79 int16_t count;
55 } pst_block_header; 80 } pst_block_header;
56 81
57 typedef struct _pst_id2_assoc { 82 typedef struct _pst_id2_assoc {
58 u_int32_t id2; 83 uint32_t id2;
59 u_int32_t id; 84 uint32_t id;
60 int32_t table2; 85 int32_t table2;
61 } pst_id2_assoc; 86 } pst_id2_assoc;
62 87
63 // this is an array of the un-encrypted values. the un-encrypted value is in the position 88 // this is an array of the un-encrypted values. the un-encrypted value is in the position
64 // of the encrypted value. ie the encrypted value 0x13 represents 0x02 89 // of the encrypted value. ie the encrypted value 0x13 represents 0x02
65 // 0 1 2 3 4 5 6 7 90 // 0 1 2 3 4 5 6 7
66 // 8 9 a b c d e f 91 // 8 9 a b c d e f
67 unsigned char comp_enc [] = 92 unsigned char comp_enc [] =
68 { 0x47, 0xf1, 0xb4, 0xe6, 0x0b, 0x6a, 0x72, 0x48, 93 { 0x47, 0xf1, 0xb4, 0xe6, 0x0b, 0x6a, 0x72, 0x48,
69 0x85, 0x4e, 0x9e, 0xeb, 0xe2, 0xf8, 0x94, 0x53, /*0x0f*/ 94 0x85, 0x4e, 0x9e, 0xeb, 0xe2, 0xf8, 0x94, 0x53, /*0x0f*/
70 0xe0, 0xbb, 0xa0, 0x02, 0xe8, 0x5a, 0x09, 0xab, 95 0xe0, 0xbb, 0xa0, 0x02, 0xe8, 0x5a, 0x09, 0xab,
71 0xdb, 0xe3, 0xba, 0xc6, 0x7c, 0xc3, 0x10, 0xdd, /*0x1f*/ 96 0xdb, 0xe3, 0xba, 0xc6, 0x7c, 0xc3, 0x10, 0xdd, /*0x1f*/
72 0x39, 0x05, 0x96, 0x30, 0xf5, 0x37, 0x60, 0x82, 97 0x39, 0x05, 0x96, 0x30, 0xf5, 0x37, 0x60, 0x82,
73 0x8c, 0xc9, 0x13, 0x4a, 0x6b, 0x1d, 0xf3, 0xfb, /*0x2f*/ 98 0x8c, 0xc9, 0x13, 0x4a, 0x6b, 0x1d, 0xf3, 0xfb, /*0x2f*/
74 0x8f, 0x26, 0x97, 0xca, 0x91, 0x17, 0x01, 0xc4, 99 0x8f, 0x26, 0x97, 0xca, 0x91, 0x17, 0x01, 0xc4,
75 0x32, 0x2d, 0x6e, 0x31, 0x95, 0xff, 0xd9, 0x23, /*0x3f*/ 100 0x32, 0x2d, 0x6e, 0x31, 0x95, 0xff, 0xd9, 0x23, /*0x3f*/
76 0xd1, 0x00, 0x5e, 0x79, 0xdc, 0x44, 0x3b, 0x1a, 101 0xd1, 0x00, 0x5e, 0x79, 0xdc, 0x44, 0x3b, 0x1a,
77 0x28, 0xc5, 0x61, 0x57, 0x20, 0x90, 0x3d, 0x83, /*0x4f*/ 102 0x28, 0xc5, 0x61, 0x57, 0x20, 0x90, 0x3d, 0x83, /*0x4f*/
78 0xb9, 0x43, 0xbe, 0x67, 0xd2, 0x46, 0x42, 0x76, 103 0xb9, 0x43, 0xbe, 0x67, 0xd2, 0x46, 0x42, 0x76,
79 0xc0, 0x6d, 0x5b, 0x7e, 0xb2, 0x0f, 0x16, 0x29, /*0x5f*/ 104 0xc0, 0x6d, 0x5b, 0x7e, 0xb2, 0x0f, 0x16, 0x29, /*0x5f*/
80 0x3c, 0xa9, 0x03, 0x54, 0x0d, 0xda, 0x5d, 0xdf, 105 0x3c, 0xa9, 0x03, 0x54, 0x0d, 0xda, 0x5d, 0xdf,
81 0xf6, 0xb7, 0xc7, 0x62, 0xcd, 0x8d, 0x06, 0xd3, /*0x6f*/ 106 0xf6, 0xb7, 0xc7, 0x62, 0xcd, 0x8d, 0x06, 0xd3, /*0x6f*/
82 0x69, 0x5c, 0x86, 0xd6, 0x14, 0xf7, 0xa5, 0x66, 107 0x69, 0x5c, 0x86, 0xd6, 0x14, 0xf7, 0xa5, 0x66,
83 0x75, 0xac, 0xb1, 0xe9, 0x45, 0x21, 0x70, 0x0c, /*0x7f*/ 108 0x75, 0xac, 0xb1, 0xe9, 0x45, 0x21, 0x70, 0x0c, /*0x7f*/
84 0x87, 0x9f, 0x74, 0xa4, 0x22, 0x4c, 0x6f, 0xbf, 109 0x87, 0x9f, 0x74, 0xa4, 0x22, 0x4c, 0x6f, 0xbf,
85 0x1f, 0x56, 0xaa, 0x2e, 0xb3, 0x78, 0x33, 0x50, /*0x8f*/ 110 0x1f, 0x56, 0xaa, 0x2e, 0xb3, 0x78, 0x33, 0x50, /*0x8f*/
86 0xb0, 0xa3, 0x92, 0xbc, 0xcf, 0x19, 0x1c, 0xa7, 111 0xb0, 0xa3, 0x92, 0xbc, 0xcf, 0x19, 0x1c, 0xa7,
87 0x63, 0xcb, 0x1e, 0x4d, 0x3e, 0x4b, 0x1b, 0x9b, /*0x9f*/ 112 0x63, 0xcb, 0x1e, 0x4d, 0x3e, 0x4b, 0x1b, 0x9b, /*0x9f*/
88 0x4f, 0xe7, 0xf0, 0xee, 0xad, 0x3a, 0xb5, 0x59, 113 0x4f, 0xe7, 0xf0, 0xee, 0xad, 0x3a, 0xb5, 0x59,
89 0x04, 0xea, 0x40, 0x55, 0x25, 0x51, 0xe5, 0x7a, /*0xaf*/ 114 0x04, 0xea, 0x40, 0x55, 0x25, 0x51, 0xe5, 0x7a, /*0xaf*/
90 0x89, 0x38, 0x68, 0x52, 0x7b, 0xfc, 0x27, 0xae, 115 0x89, 0x38, 0x68, 0x52, 0x7b, 0xfc, 0x27, 0xae,
91 0xd7, 0xbd, 0xfa, 0x07, 0xf4, 0xcc, 0x8e, 0x5f, /*0xbf*/ 116 0xd7, 0xbd, 0xfa, 0x07, 0xf4, 0xcc, 0x8e, 0x5f, /*0xbf*/
92 0xef, 0x35, 0x9c, 0x84, 0x2b, 0x15, 0xd5, 0x77, 117 0xef, 0x35, 0x9c, 0x84, 0x2b, 0x15, 0xd5, 0x77,
93 0x34, 0x49, 0xb6, 0x12, 0x0a, 0x7f, 0x71, 0x88, /*0xcf*/ 118 0x34, 0x49, 0xb6, 0x12, 0x0a, 0x7f, 0x71, 0x88, /*0xcf*/
94 0xfd, 0x9d, 0x18, 0x41, 0x7d, 0x93, 0xd8, 0x58, 119 0xfd, 0x9d, 0x18, 0x41, 0x7d, 0x93, 0xd8, 0x58,
95 0x2c, 0xce, 0xfe, 0x24, 0xaf, 0xde, 0xb8, 0x36, /*0xdf*/ 120 0x2c, 0xce, 0xfe, 0x24, 0xaf, 0xde, 0xb8, 0x36, /*0xdf*/
96 0xc8, 0xa1, 0x80, 0xa6, 0x99, 0x98, 0xa8, 0x2f, 121 0xc8, 0xa1, 0x80, 0xa6, 0x99, 0x98, 0xa8, 0x2f,
97 0x0e, 0x81, 0x65, 0x73, 0xe4, 0xc2, 0xa2, 0x8a, /*0xef*/ 122 0x0e, 0x81, 0x65, 0x73, 0xe4, 0xc2, 0xa2, 0x8a, /*0xef*/
98 0xd4, 0xe1, 0x11, 0xd0, 0x08, 0x8b, 0x2a, 0xf2, 123 0xd4, 0xe1, 0x11, 0xd0, 0x08, 0x8b, 0x2a, 0xf2,
99 0xed, 0x9a, 0x64, 0x3f, 0xc1, 0x6c, 0xf9, 0xec}; /*0xff*/ 124 0xed, 0x9a, 0x64, 0x3f, 0xc1, 0x6c, 0xf9, 0xec}; /*0xff*/
125
126
127 void dump_desc(off_t off, int depth, int i, pst_descn *desc_rec ) { // {{{
128 //desc_rec->d_id = 0x0102030405060708;
129 DEBUG_INDEX(("%08x [%i] Item(%#x) = [d_id = %#llx, desc_id = %#llx, "
130 "list_id = %#llx, parent_id = %#x, u1 = %#x] %#x %p %p\n",
131 off,
132 depth, i, desc_rec->d_id,
133 desc_rec->desc_id, desc_rec->list_id, desc_rec->parent_id, desc_rec->u1));
134 DEBUG_HEXDUMPC( (char*)desc_rec, sizeof( pst_descn ), 0x10 );
135 DEBUG_INDEX(("WTF? %d %x %x %x %x %x\n",
136 sizeof( uint32_t ),
137 (int)(&desc_rec->d_id) - (int)desc_rec,
138 (int)(&desc_rec->desc_id) - (int)desc_rec,
139 (int)(&desc_rec->list_id) - (int)desc_rec,
140 (int)(&desc_rec->parent_id) - (int)desc_rec,
141 (int)(&desc_rec->u1) - (int)desc_rec ));
142 }
143
100 144
101 int32_t pst_open(pst_file *pf, char *name, char *mode) { 145 int32_t pst_open(pst_file *pf, char *name, char *mode) {
102 u_int32_t sig; 146 uint32_t sig;
103 147
104 DEBUG_ENT("pst_open"); 148 DEBUG_ENT("pst_open");
105 149
106 if (!pf) { 150 if (!pf) {
107 WARN (("cannot be passed a NULL pst_file\n")); 151 WARN (("cannot be passed a NULL pst_file\n"));
108 DEBUG_RET(); 152 DEBUG_RET();
109 return -1; 153 return -1;
110 } 154 }
111 memset(pf, 0, sizeof(pst_file)); 155 memset(pf, 0, sizeof(pst_file));
112 156
113 #ifdef _MSC_VER 157 #ifdef _MSC_VER
114 // set the default open mode for windows 158 // set the default open mode for windows
115 _fmode = _O_BINARY; 159 _fmode = _O_BINARY;
116 #endif //_MSC_VER 160 #endif //_MSC_VER
117 if ((pf->fp = fopen(name, mode)) == NULL) { 161 if ((pf->fp = fopen(name, mode)) == NULL) {
118 WARN(("cannot open PST file. Error\n")); 162 WARN(("cannot open PST file. Error\n"));
119 DEBUG_RET(); 163 DEBUG_RET();
120 return -1; 164 return -1;
121 } 165 }
122 166
123 // Check pst file magic 167 // Check pst file magic
124 if (fread(&sig, sizeof(sig), 1, pf->fp) == 0) { 168 if (fread(&sig, sizeof(sig), 1, pf->fp) == 0) {
125 fclose(pf->fp); 169 fclose(pf->fp);
126 WARN(("cannot read signature from PST file. Closing on error\n")); 170 WARN(("cannot read signature from PST file. Closing on error\n"));
127 DEBUG_RET(); 171 DEBUG_RET();
128 return -1; 172 return -1;
129 } 173 }
130 LE32_CPU(sig); // architecture independant byte-swapping (little, big, pdp) 174 LE32_CPU(sig);
131 DEBUG_INFO(("sig = %X\n", sig)); 175 DEBUG_INFO(("sig = %X\n", sig));
132 if (sig != PST_SIGNATURE) { 176 if (sig != PST_SIGNATURE) {
133 fclose(pf->fp); 177 fclose(pf->fp);
134 WARN(("not a PST file that I know. Closing with error\n")); 178 WARN(("not a PST file that I know. Closing with error\n"));
135 DEBUG_RET(); 179 DEBUG_RET();
136 return -1; 180 return -1;
137 } 181 }
138 182
139 // read index type 183 // read index type
140 _pst_getAtPos(pf->fp, INDEX_TYPE_OFFSET, &(pf->ind_type), sizeof(unsigned char)); 184 do_read64 = 0; // start with 32 bit format
141 DEBUG_INFO(("index_type = %i\n", pf->ind_type)); 185 _pst_getAtPos(pf->fp, INDEX_TYPE_OFFSET, &(pf->ind_type), sizeof(unsigned char));
142 if (pf->ind_type != 0x0E) { 186 DEBUG_INFO(("index_type = %i\n", pf->ind_type));
143 WARN(("unknown index structure. Could this be a new Outlook 2003 PST file?\n")); 187 if (pf->ind_type != INDEX_TYPE) {
144 DEBUG_RET(); 188 // try with 64 bit format
145 return -1; 189 do_read64 = 1;
146 } 190 if (pf->ind_type != INDEX_TYPE) {
147 191 WARN(("unknown .pst format, possibly newer than Outlook 2003 PST file?\n"));
148 // read encryption setting 192 DEBUG_RET();
149 _pst_getAtPos(pf->fp, ENC_OFFSET, &(pf->encryption), sizeof(unsigned char)); 193 return -1;
150 DEBUG_INFO(("encrypt = %i\n", pf->encryption)); 194 }
151 195 }
152 _pst_getAtPos(pf->fp, SECOND_POINTER-4, &(pf->index2_count), sizeof(pf->index2_count)); 196
153 _pst_getAtPos(pf->fp, SECOND_POINTER, &(pf->index2), sizeof(pf->index2)); 197 // read encryption setting
154 LE32_CPU(pf->index2_count); 198 _pst_getAtPos(pf->fp, ENC_OFFSET, &(pf->encryption), sizeof(unsigned char));
155 LE32_CPU(pf->index2); 199 DEBUG_INFO(("encrypt = %i\n", pf->encryption));
156 DEBUG_INFO(("Pointer2 is %#X, count %i[%#x]\n", pf->index2, pf->index2_count, pf->index2_count)); 200
157 201 pf->index2_count = _pst_getIntAtPos(pf->fp, SECOND_COUNT);
158 _pst_getAtPos(pf->fp, FILE_SIZE_POINTER, &(pf->size), sizeof(pf->size)); 202 pf->index2 = _pst_getIntAtPos(pf->fp, SECOND_POINTER );
159 LE32_CPU(pf->size); 203 pf->size = _pst_getIntAtPos( pf->fp, FILE_SIZE_POINTER );
160 204 DEBUG_INFO(("Pointer2 is %#X, count %i[%#x]\n", pf->index2, pf->index2_count, pf->index2_count));
161 _pst_getAtPos(pf->fp, INDEX_POINTER-4, &(pf->index1_count), sizeof(pf->index1_count)); 205
162 _pst_getAtPos(pf->fp, INDEX_POINTER, &(pf->index1), sizeof(pf->index1)); 206 pf->index1_count = _pst_getIntAtPos(pf->fp, INDEX_COUNT);
163 LE32_CPU(pf->index1_count); 207 pf->index1 = _pst_getIntAtPos(pf->fp, INDEX_POINTER);
164 LE32_CPU(pf->index1); 208 DEBUG_INFO(("Pointer1 is %#X, count %i[%#x]\n", pf->index1, pf->index1_count, pf->index1_count));
165 DEBUG_INFO(("Pointer1 is %#X, count %i[%#x]\n", pf->index1, pf->index1_count, pf->index1_count)); 209
166 210 DEBUG_RET();
167 DEBUG_RET(); 211 return 0;
168 return 0;
169 } 212 }
170 213
171 214
172 int32_t pst_close(pst_file *pf) { 215 int32_t pst_close(pst_file *pf) {
173 DEBUG_ENT("pst_close"); 216 DEBUG_ENT("pst_close");
174 if (!pf->fp) { 217 if (!pf->fp) {
175 WARN(("cannot close NULL fp\n")); 218 WARN(("cannot close NULL fp\n"));
176 DEBUG_RET(); 219 DEBUG_RET();
177 return -1; 220 return -1;
178 } 221 }
179 if (fclose(pf->fp)) { 222 if (fclose(pf->fp)) {
180 WARN(("fclose returned non-zero value\n")); 223 WARN(("fclose returned non-zero value\n"));
181 DEBUG_RET(); 224 DEBUG_RET();
182 return -1; 225 return -1;
183 } 226 }
184 // we must free the id linklist and the desc tree 227 // we must free the id linklist and the desc tree
185 _pst_free_id (pf->i_head); 228 _pst_free_id (pf->i_head);
186 _pst_free_desc (pf->d_head); 229 _pst_free_desc (pf->d_head);
187 _pst_free_xattrib (pf->x_head); 230 _pst_free_xattrib (pf->x_head);
188 DEBUG_RET(); 231 DEBUG_RET();
189 return 0; 232 return 0;
190 } 233 }
191 234
192 235
193 pst_desc_ll* pst_getTopOfFolders(pst_file *pf, pst_item *root) { 236 pst_desc_ll* pst_getTopOfFolders(pst_file *pf, pst_item *root) {
194 pst_desc_ll *ret; 237 pst_desc_ll *ret;
195 DEBUG_ENT("pst_getTopOfFolders"); 238 DEBUG_ENT("pst_getTopOfFolders");
196 if (!root || !root->message_store) { 239 if (!root || !root->message_store) {
197 DEBUG_INDEX(("There isn't a top of folder record here.\n")); 240 DEBUG_INDEX(("There isn't a top of folder record here.\n"));
198 ret = NULL; 241 ret = NULL;
199 } else if (!root->message_store->top_of_personal_folder) { 242 } else if (!root->message_store->top_of_personal_folder) {
200 // this is the OST way 243 // this is the OST way
201 // ASSUMPTION: Top Of Folders record in PST files is *always* descid 0x2142 244 // ASSUMPTION: Top Of Folders record in PST files is *always* descid 0x2142
202 ret = _pst_getDptr(pf, 0x2142); 245 ret = _pst_getDptr(pf, 0x2142);
203 } else { 246 } else {
204 ret = _pst_getDptr(pf, root->message_store->top_of_personal_folder->id); 247 ret = _pst_getDptr(pf, root->message_store->top_of_personal_folder->id);
205 } 248 }
206 DEBUG_RET(); 249 DEBUG_RET();
207 return ret; 250 return ret;
208 } 251 }
209 252
210 253
211 int32_t pst_attach_to_mem(pst_file *pf, pst_item_attach *attach, unsigned char **b){ 254 int32_t pst_attach_to_mem(pst_file *pf, pst_item_attach *attach, unsigned char **b){
212 int32_t size=0; 255 int32_t size=0;
213 pst_index_ll *ptr; 256 pst_index_ll *ptr;
214 struct holder h = {b, NULL, 0, "", 0}; 257 struct holder h = {b, NULL, 0, "", 0};
215 DEBUG_ENT("pst_attach_to_mem"); 258 DEBUG_ENT("pst_attach_to_mem");
216 if (attach->id_val != -1) { 259 if (attach->id_val != -1) {
217 ptr = _pst_getID(pf, attach->id_val); 260 ptr = _pst_getID(pf, attach->id_val);
218 if (ptr) { 261 if (ptr) {
219 size = _pst_ff_getID2data(pf, ptr, &h); 262 size = _pst_ff_getID2data(pf, ptr, &h);
220 } else { 263 } else {
221 DEBUG_WARN(("Couldn't find ID pointer. Cannot handle attachment\n")); 264 DEBUG_WARN(("Couldn't find ID pointer. Cannot handle attachment\n"));
222 size = 0; 265 size = 0;
223 } 266 }
224 attach->size = size; // may as well update it to what is correct for this instance 267 attach->size = size; // may as well update it to what is correct for this instance
225 } else { 268 } else {
226 size = attach->size; 269 size = attach->size;
227 } 270 }
228 DEBUG_RET(); 271 DEBUG_RET();
229 return size; 272 return size;
230 } 273 }
231 274
232 275
233 int32_t pst_attach_to_file(pst_file *pf, pst_item_attach *attach, FILE* fp) { 276 int32_t pst_attach_to_file(pst_file *pf, pst_item_attach *attach, FILE* fp) {
234 pst_index_ll *ptr; 277 pst_index_ll *ptr;
235 struct holder h = {NULL, fp, 0, "", 0}; 278 struct holder h = {NULL, fp, 0, "", 0};
236 int32_t size; 279 int32_t size;
237 DEBUG_ENT("pst_attach_to_file"); 280 DEBUG_ENT("pst_attach_to_file");
238 if (attach->id_val != -1) { 281 if (attach->id_val != -1) {
239 ptr = _pst_getID(pf, attach->id_val); 282 ptr = _pst_getID(pf, attach->id_val);
240 if (ptr) { 283 if (ptr) {
241 size = _pst_ff_getID2data(pf, ptr, &h); 284 size = _pst_ff_getID2data(pf, ptr, &h);
242 } else { 285 } else {
243 DEBUG_WARN(("Couldn't find ID pointer. Cannot save attachment to file\n")); 286 DEBUG_WARN(("Couldn't find ID pointer. Cannot save attachment to file\n"));
244 size = 0; 287 size = 0;
245 } 288 }
246 attach->size = size; 289 attach->size = size;
247 } else { 290 } else {
248 // save the attachment to file 291 // save the attachment to file
249 size = attach->size; 292 size = attach->size;
250 pst_fwrite(attach->data, 1, size, fp); 293 pst_fwrite(attach->data, 1, size, fp);
251 } 294 }
252 DEBUG_RET(); 295 DEBUG_RET();
253 return 1; 296 return 1;
254 } 297 }
255 298
256 299
257 int32_t pst_attach_to_file_base64(pst_file *pf, pst_item_attach *attach, FILE* fp) { 300 int32_t pst_attach_to_file_base64(pst_file *pf, pst_item_attach *attach, FILE* fp) {
258 pst_index_ll *ptr; 301 pst_index_ll *ptr;
259 struct holder h = {NULL, fp, 1, "", 0}; 302 struct holder h = {NULL, fp, 1, "", 0};
260 int32_t size; 303 int32_t size;
261 char *c; 304 char *c;
262 DEBUG_ENT("pst_attach_to_file_base64"); 305 DEBUG_ENT("pst_attach_to_file_base64");
263 if (attach->id_val != -1) { 306 if (attach->id_val != -1) {
264 ptr = _pst_getID(pf, attach->id_val); 307 ptr = _pst_getID(pf, attach->id_val);
265 if (ptr) { 308 if (ptr) {
266 size = _pst_ff_getID2data(pf, ptr, &h); 309 size = _pst_ff_getID2data(pf, ptr, &h);
267 // will need to encode any bytes left over 310 // will need to encode any bytes left over
268 c = base64_encode(h.base64_extra_chars, h.base64_extra); 311 c = base64_encode(h.base64_extra_chars, h.base64_extra);
269 if (c) { 312 if (c) {
270 pst_fwrite(c, 1, strlen(c), fp); 313 pst_fwrite(c, 1, strlen(c), fp);
271 free(c); // caught by valgrind 314 free(c); // caught by valgrind
272 } 315 }
273 } else { 316 } else {
274 DEBUG_WARN (("Couldn't find ID pointer. Cannot save attachment to Base64\n")); 317 DEBUG_WARN (("Couldn't find ID pointer. Cannot save attachment to Base64\n"));
275 size = 0; 318 size = 0;
276 } 319 }
277 attach->size = size; 320 attach->size = size;
278 } else { 321 } else {
279 // encode the attachment to the file 322 // encode the attachment to the file
280 c = base64_encode(attach->data, attach->size); 323 c = base64_encode(attach->data, attach->size);
281 if (c) { 324 if (c) {
282 pst_fwrite(c, 1, strlen(c), fp); 325 pst_fwrite(c, 1, strlen(c), fp);
283 free(c); // caught by valgrind 326 free(c); // caught by valgrind
284 } 327 }
285 size = attach->size; 328 size = attach->size;
286 } 329 }
287 DEBUG_RET(); 330 DEBUG_RET();
288 return 1; 331 return 1;
289 } 332 }
290 333
291 334
292 int32_t pst_load_index (pst_file *pf) { 335 int32_t pst_load_index (pst_file *pf) {
293 int32_t x; 336 int32_t x;
294 u_int32_t y; 337 uint64_t y;
295 DEBUG_ENT("pst_load_index"); 338 DEBUG_ENT("pst_load_index");
296 if (!pf) { 339 if (!pf) {
297 WARN(("Cannot load index for a NULL pst_file\n")); 340 WARN(("Cannot load index for a NULL pst_file\n"));
298 DEBUG_RET(); 341 DEBUG_RET();
299 return -1; 342 return -1;
300 } 343 }
301 344
302 x = _pst_build_id_ptr(pf, pf->index1, 0, pf->index1_count, 0, INT32_MAX); 345 x = _pst_build_id_ptr(pf, pf->index1, 0, pf->index1_count, 0, UINT64_MAX);
303 DEBUG_INDEX(("build id ptr returns %i\n", x)); 346 DEBUG_INDEX(("build id ptr returns %i\n", x));
304 347
305 y = 0; 348 y = 0;
306 x = _pst_build_desc_ptr(pf, pf->index2, 0, pf->index2_count, &y, 0x21, INT32_MAX); 349 x = _pst_build_desc_ptr(pf, pf->index2, 0, pf->index2_count, &y, 0x21, UINT64_MAX);
307 DEBUG_INDEX(("build desc ptr returns %i\n", x)); 350 DEBUG_INDEX(("build desc ptr returns %i\n", x));
308 351
309 DEBUG_CODE(_pst_printDptr(pf);); 352 DEBUG_CODE(_pst_printDptr(pf););
310 DEBUG_RET(); 353 DEBUG_RET();
311 return 0; 354 return 0;
312 } 355 }
313 356
314 357
315 pst_desc_ll* pst_getNextDptr(pst_desc_ll* d) { 358 pst_desc_ll* pst_getNextDptr(pst_desc_ll* d) {
316 pst_desc_ll* r = NULL; 359 pst_desc_ll* r = NULL;
317 DEBUG_ENT("pst_getNextDptr"); 360 DEBUG_ENT("pst_getNextDptr");
318 if (d) { 361 if (d) {
319 if ((r = d->child) == NULL) { 362 if ((r = d->child) == NULL) {
320 while (!d->next && d->parent) d = d->parent; 363 while (!d->next && d->parent) d = d->parent;
321 r = d->next; 364 r = d->next;
322 } 365 }
323 } 366 }
324 DEBUG_RET(); 367 DEBUG_RET();
325 return r; 368 return r;
326 } 369 }
327 370
328 371
329 typedef struct _pst_x_attrib { 372 typedef struct _pst_x_attrib {
330 u_int16_t extended; 373 uint16_t extended;
331 u_int16_t zero; 374 uint16_t zero;
332 u_int16_t type; 375 uint16_t type;
333 u_int16_t map; 376 uint16_t map;
334 } pst_x_attrib; 377 } pst_x_attrib;
335 378
336 379
337 int32_t pst_load_extended_attributes(pst_file *pf) { 380 int32_t pst_load_extended_attributes(pst_file *pf) {
338 // for PST files this will load up ID2 0x61 and check it's "list" attribute. 381 // for PST files this will load up ID2 0x61 and check it's "list" attribute.
339 pst_desc_ll *p; 382 pst_desc_ll *p;
340 pst_num_array *na; 383 pst_num_array *na;
341 pst_index2_ll *list2 = NULL; 384 pst_index2_ll *list2 = NULL;
342 unsigned char * buffer=NULL, *headerbuffer=NULL;//, *tc; 385 unsigned char * buffer=NULL, *headerbuffer=NULL;//, *tc;
343 pst_x_attrib xattrib; 386 pst_x_attrib xattrib;
344 int32_t bptr = 0, bsize, hsize, tint, err=0, x; 387 int32_t bptr = 0, bsize, hsize, tint, err=0, x;
345 pst_x_attrib_ll *ptr, *p_head=NULL, *p_sh=NULL, *p_sh2=NULL; 388 pst_x_attrib_ll *ptr, *p_head=NULL, *p_sh=NULL, *p_sh2=NULL;
346 389
347 DEBUG_ENT("pst_loadExtendedAttributes"); 390 DEBUG_ENT("pst_loadExtendedAttributes");
348 if ((p = _pst_getDptr(pf, 0x61)) == NULL) { 391 if ((p = _pst_getDptr(pf, 0x61)) == NULL) {
349 DEBUG_WARN(("Cannot find DescID 0x61 for loading the Extended Attributes\n")); 392 DEBUG_WARN(("Cannot find DescID 0x61 for loading the Extended Attributes\n"));
350 DEBUG_RET(); 393 DEBUG_RET();
351 return 0; 394 return 0;
352 } 395 }
353 396
354 if (!p->desc) { 397 if (!p->desc) {
355 DEBUG_WARN(("desc is NULL for item 0x61. Cannot load Extended Attributes\n")); 398 DEBUG_WARN(("desc is NULL for item 0x61. Cannot load Extended Attributes\n"));
356 DEBUG_RET(); 399 DEBUG_RET();
357 return 0; 400 return 0;
358 } 401 }
359 402
360 if (p->list_index) { 403 if (p->list_index) {
361 list2 = _pst_build_id2(pf, p->list_index, NULL); 404 list2 = _pst_build_id2(pf, p->list_index, NULL);
362 _pst_printID2ptr(list2); 405 _pst_printID2ptr(list2);
363 } else { 406 } else {
364 DEBUG_WARN(("Have not been able to fetch any id2 values for item 0x61. Brace yourself!\n")); 407 DEBUG_WARN(("Have not been able to fetch any id2 values for item 0x61. Brace yourself!\n"));
365 } 408 }
366 409
367 na = _pst_parse_block(pf, p->desc->id, list2); 410 na = _pst_parse_block(pf, p->desc->id, list2);
368 if (!na) { 411 if (!na) {
369 DEBUG_WARN(("Cannot process desc block for item 0x61. Not loading extended Attributes\n")); 412 DEBUG_WARN(("Cannot process desc block for item 0x61. Not loading extended Attributes\n"));
370 if (list2) _pst_free_id2(list2); 413 if (list2) _pst_free_id2(list2);
371 DEBUG_RET(); 414 DEBUG_RET();
372 return 0; 415 return 0;
373 } 416 }
374 417
375 x = 0; 418 x = 0;
376 while (x < na->count_item) { 419 while (x < na->count_item) {
377 if (na->items[x]->id == 0x0003) { 420 if (na->items[x]->id == 0x0003) {
378 buffer = na->items[x]->data; 421 buffer = na->items[x]->data;
379 bsize = na->items[x]->size; 422 bsize = na->items[x]->size;
380 } else if (na->items[x]->id == 0x0004) { 423 } else if (na->items[x]->id == 0x0004) {
381 headerbuffer = na->items[x]->data; 424 headerbuffer = na->items[x]->data;
382 hsize = na->items[x]->size; 425 hsize = na->items[x]->size;
383 } 426 }
384 x++; 427 x++;
385 } 428 }
386 429
387 if (!buffer) { 430 if (!buffer) {
388 if (na) _pst_free_list(na); 431 if (na) _pst_free_list(na);
389 DEBUG_WARN(("No extended attributes buffer found. Not processing\n")); 432 DEBUG_WARN(("No extended attributes buffer found. Not processing\n"));
390 DEBUG_RET(); 433 DEBUG_RET();
391 return 0; 434 return 0;
392 } 435 }
393 436
394 memcpy(&xattrib, &(buffer[bptr]), sizeof(xattrib)); 437 memcpy(&xattrib, &(buffer[bptr]), sizeof(xattrib));
395 LE16_CPU(xattrib.extended); 438 LE16_CPU(xattrib.extended);
396 LE16_CPU(xattrib.zero); 439 LE16_CPU(xattrib.zero);
397 LE16_CPU(xattrib.type); 440 LE16_CPU(xattrib.type);
398 LE16_CPU(xattrib.map); 441 LE16_CPU(xattrib.map);
399 bptr += sizeof(xattrib); 442 bptr += sizeof(xattrib);
400 443
401 while (xattrib.type != 0 && bptr < bsize) { 444 while (xattrib.type != 0 && bptr < bsize) {
402 ptr = (pst_x_attrib_ll*) xmalloc(sizeof(pst_x_attrib_ll)); 445 ptr = (pst_x_attrib_ll*) xmalloc(sizeof(pst_x_attrib_ll));
403 memset(ptr, 0, sizeof(pst_x_attrib_ll)); 446 memset(ptr, 0, sizeof(pst_x_attrib_ll));
404 ptr->type = xattrib.type; 447 ptr->type = xattrib.type;
405 ptr->map = xattrib.map+0x8000; 448 ptr->map = xattrib.map+0x8000;
406 ptr->next = NULL; 449 ptr->next = NULL;
407 DEBUG_INDEX(("xattrib: ext = %#hx, zero = %#hx, type = %#hx, map = %#hx\n", 450 DEBUG_INDEX(("xattrib: ext = %#hx, zero = %#hx, type = %#hx, map = %#hx\n",
408 xattrib.extended, xattrib.zero, xattrib.type, xattrib.map)); 451 xattrib.extended, xattrib.zero, xattrib.type, xattrib.map));
409 err=0; 452 err=0;
410 if (xattrib.type & 0x0001) { // if the Bit 1 is set 453 if (xattrib.type & 0x0001) { // if the Bit 1 is set
411 // pointer to Unicode field in buffer 454 // pointer to Unicode field in buffer
412 if (xattrib.extended < hsize) { 455 if (xattrib.extended < hsize) {
413 char *wt; 456 char *wt;
414 // copy the size of the header. It is 32 bit int 457 // copy the size of the header. It is 32 bit int
415 memcpy(&tint, &(headerbuffer[xattrib.extended]), sizeof(tint)); 458 memcpy(&tint, &(headerbuffer[xattrib.extended]), sizeof(tint));
416 LE32_CPU(tint); 459 LE32_CPU(tint);
417 wt = (char*) xmalloc(tint+2); // plus 2 for a uni-code zero 460 wt = (char*) xmalloc(tint+2); // plus 2 for a uni-code zero
418 memset(wt, 0, tint+2); 461 memset(wt, 0, tint+2);
419 memcpy(wt, &(headerbuffer[xattrib.extended+sizeof(tint)]), tint); 462 memcpy(wt, &(headerbuffer[xattrib.extended+sizeof(tint)]), tint);
420 ptr->data = _pst_wide_to_single(wt, tint); 463 ptr->data = _pst_wide_to_single(wt, tint);
421 free(wt); 464 free(wt);
422 DEBUG_INDEX(("Read string (converted from UTF-16): %s\n", ptr->data)); 465 DEBUG_INDEX(("Read string (converted from UTF-16): %s\n", ptr->data));
423 } else { 466 } else {
424 DEBUG_INDEX(("Cannot read outside of buffer [%i !< %i]\n", xattrib.extended, hsize)); 467 DEBUG_INDEX(("Cannot read outside of buffer [%i !< %i]\n", xattrib.extended, hsize));
425 } 468 }
426 ptr->mytype = PST_MAP_HEADER; 469 ptr->mytype = PST_MAP_HEADER;
427 } else { 470 } else {
428 // contains the attribute code to map to. 471 // contains the attribute code to map to.
429 ptr->data = (int*)xmalloc(sizeof(int32_t)); 472 ptr->data = (int*)xmalloc(sizeof(int32_t));
430 memset(ptr->data, 0, sizeof(int32_t)); 473 memset(ptr->data, 0, sizeof(int32_t));
431 *((int32_t*)ptr->data) = xattrib.extended; 474 *((int32_t*)ptr->data) = xattrib.extended;
432 ptr->mytype = PST_MAP_ATTRIB; 475 ptr->mytype = PST_MAP_ATTRIB;
433 DEBUG_INDEX(("Mapped attribute %#x to %#x\n", ptr->map, *((int32_t*)ptr->data))); 476 DEBUG_INDEX(("Mapped attribute %#x to %#x\n", ptr->map, *((int32_t*)ptr->data)));
434 } 477 }
435 478
436 if (err==0) { 479 if (err==0) {
437 // add it to the list 480 // add it to the list
438 p_sh = p_head; 481 p_sh = p_head;
439 p_sh2 = NULL; 482 p_sh2 = NULL;
440 while (p_sh && ptr->map > p_sh->map) { 483 while (p_sh && ptr->map > p_sh->map) {
441 p_sh2 = p_sh; 484 p_sh2 = p_sh;
442 p_sh = p_sh->next; 485 p_sh = p_sh->next;
443 } 486 }
444 if (!p_sh2) { 487 if (!p_sh2) {
445 // needs to go before first item 488 // needs to go before first item
446 ptr->next = p_head; 489 ptr->next = p_head;
447 p_head = ptr; 490 p_head = ptr;
448 } else { 491 } else {
449 // it will go after p_sh2 492 // it will go after p_sh2
450 ptr->next = p_sh2->next; 493 ptr->next = p_sh2->next;
451 p_sh2->next = ptr; 494 p_sh2->next = ptr;
452 } 495 }
453 } else { 496 } else {
454 free(ptr); 497 free(ptr);
455 ptr = NULL; 498 ptr = NULL;
456 } 499 }
457 memcpy(&xattrib, &(buffer[bptr]), sizeof(xattrib)); 500 memcpy(&xattrib, &(buffer[bptr]), sizeof(xattrib));
458 LE16_CPU(xattrib.extended); 501 LE16_CPU(xattrib.extended);
459 LE16_CPU(xattrib.zero); 502 LE16_CPU(xattrib.zero);
460 LE16_CPU(xattrib.type); 503 LE16_CPU(xattrib.type);
461 LE16_CPU(xattrib.map); 504 LE16_CPU(xattrib.map);
462 bptr += sizeof(xattrib); 505 bptr += sizeof(xattrib);
463 } 506 }
464 if (list2) _pst_free_id2(list2); 507 if (list2) _pst_free_id2(list2);
465 if (na) _pst_free_list(na); 508 if (na) _pst_free_list(na);
466 pf->x_head = p_head; 509 pf->x_head = p_head;
467 DEBUG_RET(); 510 DEBUG_RET();
468 return 1; 511 return 1;
469 } 512 }
470 513
471 514
472 #define BLOCK_SIZE 516 // index blocks 515 #define BLOCK_SIZE 516 // index blocks
473 #define DESC_BLOCK_SIZE 516 // descriptor blocks was 520 but bogus 516 #define DESC_BLOCK_SIZE 516 // descriptor blocks
474 #define ITEM_COUNT_OFFSET 0x1f0 // count byte 517 #define ITEM_COUNT_OFFSET 0x1f0 // count byte
475 #define LEVEL_INDICATOR_OFFSET 0x1f3 // node or leaf 518 #define LEVEL_INDICATOR_OFFSET 0x1f3 // node or leaf
476 #define BACKLINK_OFFSET 0x1f8 // backlink u1 value 519 #define BACKLINK_OFFSET 0x1f8 // backlink u1 value
477 #define ITEM_SIZE 12 520 #define ITEM_SIZE 12
478 #define DESC_SIZE 16 521 #define DESC_SIZE 16
479 #define INDEX_COUNT_MAX 41 // max active items 522 #define INDEX_COUNT_MAX 41 // max active items
480 #define DESC_COUNT_MAX 31 // max active items 523 #define DESC_COUNT_MAX 31 // max active items
481 524
482 int32_t _pst_build_id_ptr(pst_file *pf, int32_t offset, int32_t depth, int32_t linku1, u_int32_t start_val, u_int32_t end_val) { 525
483 struct _pst_table_ptr_struct table, table2; 526 int _pst_decode_desc( pst_descn *desc, char *buf ) {
484 pst_index_ll *i_ptr=NULL; 527 int r;
485 pst_index index; 528 if (do_read64) {
486 int32_t x, item_count; 529 DEBUG_INDEX(("Decoding desc64 "));
487 u_int32_t old = start_val; 530 DEBUG_HEXDUMPC(buf, sizeof(pst_descn), 0x10);
488 char *buf = NULL, *bptr; 531 memcpy(desc, buf, sizeof(pst_descn));
489 532 LE64_CPU(desc->d_id);
490 DEBUG_ENT("_pst_build_id_ptr"); 533 LE64_CPU(desc->desc_id);
491 DEBUG_INDEX(("offset %x depth %i linku1 %x start %x end %x\n", offset, depth, linku1, start_val, end_val)); 534 LE64_CPU(desc->list_id);
492 if (end_val <= start_val) { 535 LE32_CPU(desc->parent_id);
493 DEBUG_WARN(("The end value is BEFORE the start value. This function will quit. Soz. [start:%#x, end:%#x]\n", start_val, end_val)); 536 LE32_CPU(desc->u1);
494 DEBUG_RET(); 537 r = sizeof(pst_descn);
495 return -1; 538 }
496 } 539 else {
497 DEBUG_INDEX(("Reading index block\n")); 540 pst_desc32 d32;
498 if (_pst_read_block_size(pf, offset, BLOCK_SIZE, &buf, 0, 0) < BLOCK_SIZE) { 541 DEBUG_INDEX(("Decoding desc32 "));
499 DEBUG_WARN(("Failed to read %i bytes\n", BLOCK_SIZE)); 542 DEBUG_HEXDUMPC(buf, sizeof(pst_desc32), 0x10);
500 if (buf) free(buf); 543 memcpy(&d32, buf, sizeof(pst_desc32));
501 DEBUG_RET(); 544 LE32_CPU(d32.d_id);
502 return -1; 545 LE32_CPU(d32.desc_id);
503 } 546 LE32_CPU(d32.list_id);
504 bptr = buf; 547 LE32_CPU(d32.parent_id);
505 DEBUG_HEXDUMPC(buf, BLOCK_SIZE, ITEM_SIZE); 548 desc->d_id = d32.d_id;
506 item_count = (int)(unsigned)(buf[ITEM_COUNT_OFFSET]); 549 desc->desc_id = d32.desc_id;
507 if (item_count > INDEX_COUNT_MAX) { 550 desc->list_id = d32.list_id;
508 DEBUG_WARN(("Item count %i too large, max is %i\n", item_count, INDEX_COUNT_MAX)); 551 desc->parent_id = d32.parent_id;
509 if (buf) free(buf); 552 desc->u1 = 0;
510 DEBUG_RET(); 553 r = sizeof(pst_desc32);
511 return -1; 554 }
512 } 555 return r;
513 memcpy(&index, buf+BACKLINK_OFFSET, sizeof(index)); 556 }
514 LE32_CPU(index.id); 557
515 if (index.id != linku1) { 558
516 DEBUG_WARN(("Backlink %#x in this node does not match required %#x\n", index.id, linku1)); 559 int _pst_decode_table( struct _pst_table_ptr_structn *table, char *buf ) {
517 if (buf) free(buf); 560 int r;
518 DEBUG_RET(); 561 if (do_read64) {
519 return -1; 562 DEBUG_INDEX(("Decoding table64"));
520 } 563 DEBUG_HEXDUMPC(buf, sizeof(struct _pst_table_ptr_structn), 0x10);
521 564 memcpy(table, buf, sizeof(struct _pst_table_ptr_structn));
522 if (buf[LEVEL_INDICATOR_OFFSET] == '\0') { 565 LE64_CPU(table->start);
523 // this node contains leaf pointers 566 LE64_CPU(table->u1);
524 x = 0; 567 LE64_CPU(table->offset);
525 while (x < item_count) { 568 r =sizeof(struct _pst_table_ptr_structn);
526 memcpy(&index, bptr, sizeof(index)); 569 }
527 LE32_CPU(index.id); 570 else {
528 LE32_CPU(index.offset); 571 struct _pst_table_ptr_struct32 t32;
529 LE16_CPU(index.size); 572 DEBUG_INDEX(("Decoding table32"));
530 LE16_CPU(index.u1); 573 DEBUG_HEXDUMPC(buf, sizeof( struct _pst_table_ptr_struct32), 0x10);
531 bptr += sizeof(index); 574 memcpy(&t32, buf, sizeof(struct _pst_table_ptr_struct32));
532 x++; 575 LE32_CPU(t32.start);
533 if (index.id == 0) break; 576 LE32_CPU(t32.u1);
534 DEBUG_INDEX(("[%i]%i Item [id = %#x, offset = %#x, u1 = %#x, size = %i(%#x)]\n", 577 LE32_CPU(t32.offset);
535 depth, x, index.id, index.offset, index.u1, index.size, index.size)); 578 table->start = t32.start;
536 // if (index.id & 0x02) DEBUG_INDEX(("two-bit set!!\n")); 579 table->u1 = t32.u1;
537 if ((index.id >= end_val) || (index.id < old)) { 580 table->offset = t32.offset;
538 DEBUG_WARN(("This item isn't right. Must be corruption, or I got it wrong!\n")); 581 r = sizeof(struct _pst_table_ptr_struct32);
539 if (buf) free(buf); 582 }
540 DEBUG_RET(); 583 return r;
541 return -1; 584 }
542 } 585
543 old = index.id; 586
544 if (x == 1) { // first entry 587 int _pst_decode_index( pst_index *index, char *buf ) {
545 if ((start_val) && (index.id != start_val)) { 588 int r;
546 DEBUG_WARN(("This item isn't right. Must be corruption, or I got it wrong!\n")); 589 if (do_read64) {
547 if (buf) free(buf); 590 DEBUG_INDEX(("Decoding index64"));
548 DEBUG_RET(); 591 DEBUG_HEXDUMPC(buf, sizeof(pst_index), 0x10);
549 return -1; 592 memcpy(index, buf, sizeof(pst_index));
550 } 593 LE64_CPU(index->id);
551 } 594 LE64_CPU(index->offset);
552 i_ptr = (pst_index_ll*) xmalloc(sizeof(pst_index_ll)); 595 LE16_CPU(index->size);
553 i_ptr->id = index.id; 596 LE16_CPU(index->u0);
554 i_ptr->offset = index.offset; 597 LE16_CPU(index->u1);
555 i_ptr->u1 = index.u1; 598 r = sizeof(pst_index);
556 i_ptr->size = index.size; 599 } else {
557 i_ptr->next = NULL; 600 pst_index32 index32;
558 if (pf->i_tail) pf->i_tail->next = i_ptr; 601 DEBUG_INDEX(("Decoding index32"));
559 if (!pf->i_head) pf->i_head = i_ptr; 602 DEBUG_HEXDUMPC(buf, sizeof(pst_index32), 0x10);
560 pf->i_tail = i_ptr; 603 memcpy(&index32, buf, sizeof(pst_index32));
561 } 604 LE32_CPU(index32->id);
562 } else { 605 LE32_CPU(index32->offset);
563 // this node contains node pointers 606 LE16_CPU(index32->size);
564 x = 0; 607 LE16_CPU(index32->u1);
565 while (x < item_count) { 608 index->id = index32.id;
566 memcpy(&table, bptr, sizeof(table)); 609 index->offset = index32.offset;
567 LE32_CPU(table.start); 610 index->size = index32.size;
568 LE32_CPU(table.u1); 611 index->u1 = index32.u1;
569 LE32_CPU(table.offset); 612 r = sizeof(pst_index32);
570 bptr += sizeof(table); 613 }
571 x++; 614 return r;
572 if (table.start == 0) break; 615 }
573 if (x < item_count) { 616
574 memcpy(&table2, bptr, sizeof(table)); 617
575 LE32_CPU(table2.start); 618 int32_t _pst_build_id_ptr(pst_file *pf, off_t offset, int32_t depth, int64_t linku1, uint64_t start_val, uint64_t end_val) {
576 } 619 struct _pst_table_ptr_structn table, table2;
577 else { 620 pst_index_ll *i_ptr=NULL;
578 table2.start = end_val; 621 pst_index index;
579 } 622 int32_t x, item_count;
580 DEBUG_INDEX(("[%i] %i Index Table [start id = %#x, u1 = %#x, offset = %#x, end id = %#x]\n", 623 uint64_t old = start_val;
581 depth, x, table.start, table.u1, table.offset, table2.start)); 624 char *buf = NULL, *bptr;
582 if ((table.start >= end_val) || (table.start < old)) { 625
583 DEBUG_WARN(("This table isn't right. Must be corruption, or I got it wrong!\n")); 626 DEBUG_ENT("_pst_build_id_ptr");
584 if (buf) free(buf); 627 DEBUG_INDEX(("offset %x depth %i linku1 %llx start %llx end %llx\n", offset, depth, linku1, start_val, end_val));
585 DEBUG_RET(); 628 if (end_val <= start_val) {
586 return -1; 629 DEBUG_WARN(("The end value is BEFORE the start value. This function will quit. Soz. [start:%#llx, end:%#llx]\n", start_val, end_val));
587 } 630 DEBUG_RET();
588 old = table.start; 631 return -1;
589 if (x == 1) { // first entry 632 }
590 if ((start_val) && (table.start != start_val)) { 633 DEBUG_INDEX(("Reading index block\n"));
591 DEBUG_WARN(("This table isn't right. Must be corruption, or I got it wrong!\n")); 634 if (_pst_read_block_size(pf, offset, BLOCK_SIZE, &buf, 0, 0) < BLOCK_SIZE) {
592 if (buf) free(buf); 635 DEBUG_WARN(("Failed to read %i bytes\n", BLOCK_SIZE));
593 DEBUG_RET(); 636 if (buf) free(buf);
594 return -1; 637 DEBUG_RET();
595 } 638 return -1;
596 } 639 }
597 _pst_build_id_ptr(pf, table.offset, depth+1, table.u1, table.start, table2.start); 640 bptr = buf;
598 } 641 DEBUG_HEXDUMPC(buf, BLOCK_SIZE, ITEM_SIZE);
599 } 642 item_count = (int)(unsigned)(buf[ITEM_COUNT_OFFSET]);
600 if (buf) free (buf); 643 if (item_count > INDEX_COUNT_MAX) {
601 DEBUG_RET(); 644 DEBUG_WARN(("Item count %i too large, max is %i\n", item_count, INDEX_COUNT_MAX));
602 return 0; 645 if (buf) free(buf);
646 DEBUG_RET();
647 return -1;
648 }
649 index.id = _getIntAt(buf+BACKLINK_OFFSET);
650 if (index.id != linku1) {
651 DEBUG_WARN(("Backlink %#llx in this node does not match required %#llx\n", index.id, linku1));
652 if (buf) free(buf);
653 DEBUG_RET();
654 return -1;
655 }
656
657 if (buf[LEVEL_INDICATOR_OFFSET] == '\0') {
658 // this node contains leaf pointers
659 x = 0;
660 while (x < item_count) {
661 bptr += _pst_decode_index(&index, bptr);
662 x++;
663 if (index.id == 0) break;
664 DEBUG_INDEX(("[%i]%i Item [id = %#x, offset = %#x, u1 = %#x, size = %i(%#x)]\n",
665 depth, x, index.id, index.offset, index.u1, index.size, index.size));
666 // if (index.id & 0x02) DEBUG_INDEX(("two-bit set!!\n"));
667 if ((index.id >= end_val) || (index.id < old)) {
668 DEBUG_WARN(("This item isn't right. Must be corruption, or I got it wrong!\n"));
669 if (buf) free(buf);
670 DEBUG_RET();
671 return -1;
672 }
673 old = index.id;
674 if (x == 1) { // first entry
675 if ((start_val) && (index.id != start_val)) {
676 DEBUG_WARN(("This item isn't right. Must be corruption, or I got it wrong!\n"));
677 if (buf) free(buf);
678 DEBUG_RET();
679 return -1;
680 }
681 }
682 i_ptr = (pst_index_ll*) xmalloc(sizeof(pst_index_ll));
683 i_ptr->id = index.id;
684 i_ptr->offset = index.offset;
685 i_ptr->u1 = index.u1;
686 i_ptr->size = index.size;
687 i_ptr->next = NULL;
688 if (pf->i_tail) pf->i_tail->next = i_ptr;
689 if (!pf->i_head) pf->i_head = i_ptr;
690 pf->i_tail = i_ptr;
691 }
692 } else {
693 // this node contains node pointers
694 x = 0;
695 while (x < item_count) {
696 bptr += _pst_decode_table(&table, bptr);
697 x++;
698 if (table.start == 0) break;
699 if (x < item_count) {
700 _pst_decode_table(&table2, bptr);
701 }
702 else {
703 table2.start = end_val;
704 }
705 DEBUG_INDEX(("[%i] %i Index Table [start id = %#x, u1 = %#x, offset = %#x, end id = %#x]\n",
706 depth, x, table.start, table.u1, table.offset, table2.start));
707 if ((table.start >= end_val) || (table.start < old)) {
708 DEBUG_WARN(("This table isn't right. Must be corruption, or I got it wrong!\n"));
709 if (buf) free(buf);
710 DEBUG_RET();
711 return -1;
712 }
713 old = table.start;
714 if (x == 1) { // first entry
715 if ((start_val) && (table.start != start_val)) {
716 DEBUG_WARN(("This table isn't right. Must be corruption, or I got it wrong!\n"));
717 if (buf) free(buf);
718 DEBUG_RET();
719 return -1;
720 }
721 }
722 _pst_build_id_ptr(pf, table.offset, depth+1, table.u1, table.start, table2.start);
723 }
724 }
725 if (buf) free (buf);
726 DEBUG_RET();
727 return 0;
603 } 728 }
604 729
605 730
606 /** this list node type is used for a quick cache 731 /** this list node type is used for a quick cache
607 of the descriptor tree nodes (rooted at pf->d_head) 732 of the descriptor tree nodes (rooted at pf->d_head)
608 and for a "lost and found" list. 733 and for a "lost and found" list.
609 If the parent isn't found yet, put it on the lost and found 734 If the parent isn't found yet, put it on the lost and found
610 list and check it each time you read a new item. 735 list and check it each time you read a new item.
611 */ 736 */
612 struct cache_list_node { 737 struct cache_list_node {
613 pst_desc_ll *ptr; 738 pst_desc_ll *ptr;
614 /** only used for lost and found lists */ 739 /** only used for lost and found lists */
615 u_int32_t parent; 740 uint32_t parent;
616 struct cache_list_node *next; 741 struct cache_list_node *next;
617 struct cache_list_node *prev; 742 struct cache_list_node *prev;
618 }; 743 };
619 struct cache_list_node *cache_head; 744 struct cache_list_node *cache_head;
620 struct cache_list_node *cache_tail; 745 struct cache_list_node *cache_tail;
621 struct cache_list_node *lostfound_head; 746 struct cache_list_node *lostfound_head;
622 int32_t cache_count; 747 int32_t cache_count;
623 748
624 749
625 /** 750 /**
626 add the d_ptr descriptor into the global tree 751 add the d_ptr descriptor into the global tree
627 */ 752 */
628 void record_descriptor(pst_file *pf, pst_desc_ll *d_ptr, u_int32_t parent_id) { 753 void record_descriptor(pst_file *pf, pst_desc_ll *d_ptr, uint32_t parent_id) {
629 struct cache_list_node *lostfound_ptr = NULL; 754 struct cache_list_node *lostfound_ptr = NULL;
630 struct cache_list_node *cache_ptr = NULL; 755 struct cache_list_node *cache_ptr = NULL;
631 pst_desc_ll *parent = NULL; 756 pst_desc_ll *parent = NULL;
632 757
633 if (parent_id == 0 || parent_id == d_ptr->id) { 758 if (parent_id == 0 || parent_id == d_ptr->id) {
634 // add top level node to the descriptor tree 759 // add top level node to the descriptor tree
635 if (parent_id == 0) { 760 if (parent_id == 0) {
636 DEBUG_INDEX(("No Parent\n")); 761 DEBUG_INDEX(("No Parent\n"));
637 } else { 762 } else {
638 DEBUG_INDEX(("Record is its own parent. What is this world coming to?\n")); 763 DEBUG_INDEX(("Record is its own parent. What is this world coming to?\n"));
639 } 764 }
640 if (pf->d_tail) pf->d_tail->next = d_ptr; 765 if (pf->d_tail) pf->d_tail->next = d_ptr;
641 if (!pf->d_head) pf->d_head = d_ptr; 766 if (!pf->d_head) pf->d_head = d_ptr;
642 d_ptr->prev = pf->d_tail; 767 d_ptr->prev = pf->d_tail;
643 pf->d_tail = d_ptr; 768 pf->d_tail = d_ptr;
644 } else { 769 } else {
645 DEBUG_INDEX(("Searching for parent\n")); 770 DEBUG_INDEX(("Searching for parent\n"));
646 // check in the cache for the parent 771 // check in the cache for the parent
647 cache_ptr = cache_head; 772 cache_ptr = cache_head;
648 while (cache_ptr && (cache_ptr->ptr->id != parent_id)) { 773 while (cache_ptr && (cache_ptr->ptr->id != parent_id)) {
649 cache_ptr = cache_ptr->next; 774 cache_ptr = cache_ptr->next;
650 } 775 }
651 if (!cache_ptr && (parent = _pst_getDptr(pf, parent_id)) == NULL) { 776 if (!cache_ptr && (parent = _pst_getDptr(pf, parent_id)) == NULL) {
652 // check in the lost/found list 777 // check in the lost/found list
653 lostfound_ptr = lostfound_head; 778 lostfound_ptr = lostfound_head;
654 while (lostfound_ptr && (lostfound_ptr->ptr->id != parent_id)) { 779 while (lostfound_ptr && (lostfound_ptr->ptr->id != parent_id)) {
655 lostfound_ptr = lostfound_ptr->next; 780 lostfound_ptr = lostfound_ptr->next;
656 } 781 }
657 if (!lostfound_ptr) { 782 if (!lostfound_ptr) {
658 DEBUG_WARN(("ERROR -- cannot find parent with id %#x. Adding to lost/found\n", parent_id)); 783 DEBUG_WARN(("ERROR -- cannot find parent with id %#x. Adding to lost/found\n", parent_id));
659 lostfound_ptr = (struct cache_list_node*) xmalloc(sizeof(struct cache_list_node)); 784 lostfound_ptr = (struct cache_list_node*) xmalloc(sizeof(struct cache_list_node));
660 lostfound_ptr->prev = NULL; 785 lostfound_ptr->prev = NULL;
661 lostfound_ptr->next = lostfound_head; 786 lostfound_ptr->next = lostfound_head;
662 lostfound_ptr->parent = parent_id; 787 lostfound_ptr->parent = parent_id;
663 lostfound_ptr->ptr = d_ptr; 788 lostfound_ptr->ptr = d_ptr;
664 lostfound_head = lostfound_ptr; 789 lostfound_head = lostfound_ptr;
665 } else { 790 } else {
666 parent = lostfound_ptr->ptr; 791 parent = lostfound_ptr->ptr;
667 DEBUG_INDEX(("Found parent (%#x) in Lost and Found\n", parent->id)); 792 DEBUG_INDEX(("Found parent (%#x) in Lost and Found\n", parent->id));
668 } 793 }
669 } 794 }
670 795
671 if (cache_ptr || parent) { 796 if (cache_ptr || parent) {
672 if (cache_ptr) 797 if (cache_ptr)
673 // parent is already in the cache 798 // parent is already in the cache
674 parent = cache_ptr->ptr; 799 parent = cache_ptr->ptr;
675 else { 800 else {
676 //add the parent to the cache 801 //add the parent to the cache
677 DEBUG_INDEX(("Cache addition\n")); 802 DEBUG_INDEX(("Cache addition\n"));
678 cache_ptr = (struct cache_list_node*) xmalloc(sizeof(struct cache_list_node)); 803 cache_ptr = (struct cache_list_node*) xmalloc(sizeof(struct cache_list_node));
679 cache_ptr->prev = NULL; 804 cache_ptr->prev = NULL;
680 cache_ptr->next = cache_head; 805 cache_ptr->next = cache_head;
681 cache_ptr->ptr = parent; 806 cache_ptr->ptr = parent;
682 cache_head = cache_ptr; 807 cache_head = cache_ptr;
683 if (!cache_tail) cache_tail = cache_ptr; 808 if (!cache_tail) cache_tail = cache_ptr;
684 cache_count++; 809 cache_count++;
685 if (cache_count > 100) { 810 if (cache_count > 100) {
686 DEBUG_INDEX(("trimming quick cache\n")); 811 DEBUG_INDEX(("trimming quick cache\n"));
687 //remove one from the end 812 //remove one from the end
688 cache_ptr = cache_tail; 813 cache_ptr = cache_tail;
689 cache_tail = cache_ptr->prev; 814 cache_tail = cache_ptr->prev;
690 free (cache_ptr); 815 free (cache_ptr);
691 cache_count--; 816 cache_count--;
692 } 817 }
693 } 818 }
694 DEBUG_INDEX(("Found a parent\n")); 819 DEBUG_INDEX(("Found a parent\n"));
695 parent->no_child++; 820 parent->no_child++;
696 d_ptr->parent = parent; 821 d_ptr->parent = parent;
697 if (parent->child_tail) parent->child_tail->next = d_ptr; 822 if (parent->child_tail) parent->child_tail->next = d_ptr;
698 if (!parent->child) parent->child = d_ptr; 823 if (!parent->child) parent->child = d_ptr;
699 d_ptr->prev = parent->child_tail; 824 d_ptr->prev = parent->child_tail;
700 parent->child_tail = d_ptr; 825 parent->child_tail = d_ptr;
701 } 826 }
702 } 827 }
703 } 828 }
704 829
705 int32_t _pst_build_desc_ptr (pst_file *pf, int32_t offset, int32_t depth, int32_t linku1, u_int32_t *high_id, u_int32_t start_val, u_int32_t end_val) { 830 int32_t _pst_build_desc_ptr (pst_file *pf, off_t offset, int32_t depth, int64_t linku1, uint64_t *high_id, uint64_t start_val, uint64_t end_val) {
706 struct _pst_table_ptr_struct table, table2; 831 struct _pst_table_ptr_structn table, table2;
707 pst_desc desc_rec; 832 pst_descn desc_rec;
708 pst_desc_ll *d_ptr=NULL, *parent=NULL; 833 pst_desc_ll *d_ptr=NULL, *parent=NULL;
709 int32_t x, item_count; 834 int32_t x, item_count;
710 u_int32_t old = start_val; 835 uint32_t old = start_val;
711 char *buf = NULL, *bptr; 836 char *buf = NULL, *bptr;
712 struct cache_list_node *cache_ptr = NULL; 837 struct cache_list_node *cache_ptr = NULL;
713 struct cache_list_node *lostfound_ptr = NULL; 838 struct cache_list_node *lostfound_ptr = NULL;
714 struct cache_list_node *lostfound_shd = NULL; 839 struct cache_list_node *lostfound_shd = NULL;
715 struct cache_list_node *lostfound_tmp = NULL; 840 struct cache_list_node *lostfound_tmp = NULL;
716 841
717 if (depth == 0) { 842 if (depth == 0) {
718 // initialize the linked list and lost/found list. 843 // initialize the linked list and lost/found list.
719 cache_head = NULL; 844 cache_head = NULL;
720 cache_tail = NULL; 845 cache_tail = NULL;
721 lostfound_head = NULL; 846 lostfound_head = NULL;
722 cache_count = 0; 847 cache_count = 0;
723 } 848 }
724 849
725 DEBUG_ENT("_pst_build_desc_ptr"); 850 DEBUG_ENT("_pst_build_desc_ptr");
726 DEBUG_INDEX(("offset %x depth %i linku1 %x start %x end %x\n", offset, depth, linku1, start_val, end_val)); 851 DEBUG_INDEX(("offset %x depth %i linku1 %x start %x end %x\n", offset, depth, linku1, start_val, end_val));
727 if (end_val <= start_val) { 852 if (end_val <= start_val) {
728 DEBUG_WARN(("The end value is BEFORE the start value. This function will quit. Soz. [start:%#x, end:%#x]\n", start_val, end_val)); 853 DEBUG_WARN(("The end value is BEFORE the start value. This function will quit. Soz. [start:%#x, end:%#x]\n", start_val, end_val));
729 DEBUG_RET(); 854 DEBUG_RET();
730 return -1; 855 return -1;
731 } 856 }
732 DEBUG_INDEX(("Reading desc block\n")); 857 DEBUG_INDEX(("Reading desc block\n"));
733 if (_pst_read_block_size(pf, offset, DESC_BLOCK_SIZE, &buf, 0, 0) < DESC_BLOCK_SIZE) { 858 if (_pst_read_block_size(pf, offset, DESC_BLOCK_SIZE, &buf, 0, 0) < DESC_BLOCK_SIZE) {
734 DEBUG_WARN(("Failed to read %i bytes\n", DESC_BLOCK_SIZE)); 859 DEBUG_WARN(("Failed to read %i bytes\n", DESC_BLOCK_SIZE));
735 if (buf) free(buf); 860 if (buf) free(buf);
736 DEBUG_RET(); 861 DEBUG_RET();
737 return -1; 862 return -1;
738 } 863 }
739 bptr = buf; 864 bptr = buf;
740 item_count = (int)(unsigned)(buf[ITEM_COUNT_OFFSET]); 865 item_count = (int)(unsigned)(buf[ITEM_COUNT_OFFSET]);
741 memcpy(&desc_rec.d_id, buf+BACKLINK_OFFSET, sizeof(u_int32_t)); // for valgrind, only have 3 ints here, not 4 866
742 LE32_CPU(desc_rec.d_id); 867 desc_rec.d_id = _getIntAt(buf+BACKLINK_OFFSET);
743 if (desc_rec.d_id != linku1) { 868 if (desc_rec.d_id != linku1) {
744 DEBUG_WARN(("Backlink %#x in this node does not match required %#x\n", desc_rec.d_id, linku1)); 869 DEBUG_WARN(("Backlink %#x in this node does not match required %#x\n", desc_rec.d_id, linku1));
745 if (buf) free(buf); 870 if (buf) free(buf);
746 DEBUG_RET(); 871 DEBUG_RET();
747 return -1; 872 return -1;
748 } 873 }
749 if (buf[LEVEL_INDICATOR_OFFSET] == '\0') { 874 if (buf[LEVEL_INDICATOR_OFFSET] == '\0') {
750 // this node contains leaf pointers 875 // this node contains leaf pointers
751 DEBUG_HEXDUMPC(buf, DESC_BLOCK_SIZE, 16); 876 DEBUG_HEXDUMPC(buf, DESC_BLOCK_SIZE, 16);
752 if (item_count > DESC_COUNT_MAX) { 877 if (item_count > DESC_COUNT_MAX) {
753 DEBUG_WARN(("Item count %i too large, max is %i\n", item_count, DESC_COUNT_MAX)); 878 DEBUG_WARN(("Item count %i too large, max is %i\n", item_count, DESC_COUNT_MAX));
754 if (buf) free(buf); 879 if (buf) free(buf);
755 DEBUG_RET(); 880 DEBUG_RET();
756 return -1; 881 return -1;
757 } 882 }
758 x = 0; 883 x = 0;
759 while (x < item_count) { 884 while (x < item_count) {
760 memcpy(&desc_rec, bptr, sizeof(desc_rec)); 885 bptr += _pst_decode_desc(&desc_rec, bptr);
761 LE32_CPU(desc_rec.d_id); 886 x++;
762 LE32_CPU(desc_rec.desc_id); 887 if (desc_rec.d_id == 0) break;
763 LE32_CPU(desc_rec.list_id); 888 DEBUG_INDEX(("[%i] Item(%#x) = [d_id = %#x, desc_id = %#x, list_id = %#x, parent_id = %#x]\n",
764 LE32_CPU(desc_rec.parent_id); 889 depth, x, desc_rec.d_id, desc_rec.desc_id, desc_rec.list_id, desc_rec.parent_id));
765 bptr+= sizeof(desc_rec); 890 if ((desc_rec.d_id >= end_val) || (desc_rec.d_id < old)) {
766 x++; 891 DEBUG_WARN(("This item isn't right. Must be corruption, or I got it wrong!\n"));
767 if (desc_rec.d_id == 0) break; 892 DEBUG_HEXDUMPC(buf, DESC_BLOCK_SIZE, 16);
768 DEBUG_INDEX(("[%i] Item(%#x) = [d_id = %#x, desc_id = %#x, list_id = %#x, parent_id = %#x]\n", 893 if (buf) free(buf);
769 depth, x, desc_rec.d_id, desc_rec.desc_id, desc_rec.list_id, desc_rec.parent_id)); 894 DEBUG_RET();
770 if ((desc_rec.d_id >= end_val) || (desc_rec.d_id < old)) { 895 return -1;
771 DEBUG_WARN(("This item isn't right. Must be corruption, or I got it wrong!\n")); 896 }
772 DEBUG_HEXDUMPC(buf, DESC_BLOCK_SIZE, 16); 897 old = desc_rec.d_id;
773 if (buf) free(buf); 898 if (x == 1) { // first entry
774 DEBUG_RET(); 899 if (start_val && (desc_rec.d_id != start_val)) {
775 return -1; 900 DEBUG_WARN(("This item isn't right. Must be corruption, or I got it wrong!\n"));
776 } 901 if (buf) free(buf);
777 old = desc_rec.d_id; 902 DEBUG_RET();
778 if (x == 1) { // first entry 903 return -1;
779 if (start_val && (desc_rec.d_id != start_val)) { 904 }
780 DEBUG_WARN(("This item isn't right. Must be corruption, or I got it wrong!\n")); 905 }
781 if (buf) free(buf); 906 // When duplicates found, just update the info.... perhaps this is correct functionality
782 DEBUG_RET(); 907 DEBUG_INDEX(("Searching for existing record\n"));
783 return -1; 908 if (desc_rec.d_id <= *high_id && (d_ptr = _pst_getDptr(pf, desc_rec.d_id))) {
784 } 909 DEBUG_INDEX(("Updating Existing Values\n"));
785 } 910 d_ptr->list_index = _pst_getID(pf, desc_rec.list_id);
786 // When duplicates found, just update the info.... perhaps this is correct functionality 911 d_ptr->desc = _pst_getID(pf, desc_rec.desc_id);
787 DEBUG_INDEX(("Searching for existing record\n")); 912 DEBUG_INDEX(("\tdesc = %#x\tlist_index=%#x\n",
788 if (desc_rec.d_id <= *high_id && (d_ptr = _pst_getDptr(pf, desc_rec.d_id))) { 913 (d_ptr->desc==NULL?0:d_ptr->desc->id),
789 DEBUG_INDEX(("Updating Existing Values\n")); 914 (d_ptr->list_index==NULL?0:d_ptr->list_index->id)));
790 d_ptr->list_index = _pst_getID(pf, desc_rec.list_id); 915 if (d_ptr->parent && desc_rec.parent_id != d_ptr->parent->id) {
791 d_ptr->desc = _pst_getID(pf, desc_rec.desc_id); 916 DEBUG_INDEX(("WARNING -- Parent of record has changed. Moving it\n"));
792 DEBUG_INDEX(("\tdesc = %#x\tlist_index=%#x\n", 917 //hmmm, we must move the record.
793 (d_ptr->desc==NULL?0:d_ptr->desc->id), 918 // first we must remove from current location
794 (d_ptr->list_index==NULL?0:d_ptr->list_index->id))); 919 // change previous record to point next to our next
795 if (d_ptr->parent && desc_rec.parent_id != d_ptr->parent->id) { 920 // if no previous, then use parent's child
796 DEBUG_INDEX(("WARNING -- Parent of record has changed. Moving it\n")); 921 // if no parent then change pf->d_head;
797 //hmmm, we must move the record. 922 // change next's prev to our prev
798 // first we must remove from current location 923 // if no next then change parent's child_tail
799 // change previous record to point next to our next 924 // if no parent then change pf->d_tail
800 // if no previous, then use parent's child 925 if (d_ptr->prev)
801 // if no parent then change pf->d_head; 926 d_ptr->prev->next = d_ptr->next;
802 // change next's prev to our prev 927 else if (d_ptr->parent)
803 // if no next then change parent's child_tail 928 d_ptr->parent->child = d_ptr->next;
804 // if no parent then change pf->d_tail 929 else
805 if (d_ptr->prev) 930 pf->d_head = d_ptr->next;
806 d_ptr->prev->next = d_ptr->next; 931
807 else if (d_ptr->parent) 932 if (d_ptr->next)
808 d_ptr->parent->child = d_ptr->next; 933 d_ptr->next->prev = d_ptr->prev;
809 else 934 else if (d_ptr->parent)
810 pf->d_head = d_ptr->next; 935 d_ptr->parent->child_tail = d_ptr->prev;
811 936 else
812 if (d_ptr->next) 937 pf->d_tail = d_ptr->prev;
813 d_ptr->next->prev = d_ptr->prev; 938
814 else if (d_ptr->parent) 939 d_ptr->prev = NULL;
815 d_ptr->parent->child_tail = d_ptr->prev; 940 d_ptr->next = NULL;
816 else 941 d_ptr->parent = NULL;
817 pf->d_tail = d_ptr->prev; 942 record_descriptor(pf, d_ptr, desc_rec.parent_id); // add to the global tree
818 943 }
819 d_ptr->prev = NULL; 944 } else {
820 d_ptr->next = NULL; 945 if (*high_id < desc_rec.d_id) {
821 d_ptr->parent = NULL; 946 DEBUG_INDEX(("Updating New High\n"));
822 record_descriptor(pf, d_ptr, desc_rec.parent_id); // add to the global tree 947 *high_id = desc_rec.d_id;
823 } 948 }
824 } else { 949 DEBUG_INDEX(("New Record\n"));
825 if (*high_id < desc_rec.d_id) { 950 d_ptr = (pst_desc_ll*) xmalloc(sizeof(pst_desc_ll));
826 DEBUG_INDEX(("Updating New High\n")); 951 d_ptr->id = desc_rec.d_id;
827 *high_id = desc_rec.d_id; 952 d_ptr->list_index = _pst_getID(pf, desc_rec.list_id);
828 } 953 d_ptr->desc = _pst_getID(pf, desc_rec.desc_id);
829 DEBUG_INDEX(("New Record\n")); 954 d_ptr->prev = NULL;
830 d_ptr = (pst_desc_ll*) xmalloc(sizeof(pst_desc_ll)); 955 d_ptr->next = NULL;
831 d_ptr->id = desc_rec.d_id; 956 d_ptr->parent = NULL;
832 d_ptr->list_index = _pst_getID(pf, desc_rec.list_id); 957 d_ptr->child = NULL;
833 d_ptr->desc = _pst_getID(pf, desc_rec.desc_id); 958 d_ptr->child_tail = NULL;
834 d_ptr->prev = NULL; 959 d_ptr->no_child = 0;
835 d_ptr->next = NULL; 960 record_descriptor(pf, d_ptr, desc_rec.parent_id); // add to the global tree
836 d_ptr->parent = NULL; 961
837 d_ptr->child = NULL; 962 }
838 d_ptr->child_tail = NULL; 963 // check here to see if d_ptr is the parent of any of the items in the lost / found list
839 d_ptr->no_child = 0; 964 lostfound_ptr = lostfound_head;
840 record_descriptor(pf, d_ptr, desc_rec.parent_id); // add to the global tree 965 lostfound_shd = NULL;
841 966 while (lostfound_ptr) {
842 } 967 if (lostfound_ptr->parent == d_ptr->id) {
843 // check here to see if d_ptr is the parent of any of the items in the lost / found list 968 DEBUG_INDEX(("Found a child (%#x) of the current record. Joining to main structure.\n", lostfound_ptr->ptr->id));
844 lostfound_ptr = lostfound_head; 969 parent = d_ptr;
845 lostfound_shd = NULL; 970 d_ptr = lostfound_ptr->ptr;
846 while (lostfound_ptr) { 971 parent->no_child++;
847 if (lostfound_ptr->parent == d_ptr->id) { 972 d_ptr->parent = parent;
848 DEBUG_INDEX(("Found a child (%#x) of the current record. Joining to main structure.\n", lostfound_ptr->ptr->id)); 973 if (parent->child_tail) parent->child_tail->next = d_ptr;
849 parent = d_ptr; 974 if (!parent->child) parent->child = d_ptr;
850 d_ptr = lostfound_ptr->ptr; 975 d_ptr->prev = parent->child_tail;
851 parent->no_child++; 976 parent->child_tail = d_ptr;
852 d_ptr->parent = parent; 977 if (!lostfound_shd) lostfound_head = lostfound_ptr->next;
853 if (parent->child_tail) parent->child_tail->next = d_ptr; 978 else lostfound_shd->next = lostfound_ptr->next;
854 if (!parent->child) parent->child = d_ptr; 979 lostfound_tmp = lostfound_ptr->next;
855 d_ptr->prev = parent->child_tail; 980 free(lostfound_ptr);
856 parent->child_tail = d_ptr; 981 lostfound_ptr = lostfound_tmp;
857 if (!lostfound_shd) lostfound_head = lostfound_ptr->next; 982 } else {
858 else lostfound_shd->next = lostfound_ptr->next; 983 lostfound_shd = lostfound_ptr;
859 lostfound_tmp = lostfound_ptr->next; 984 lostfound_ptr = lostfound_ptr->next;
860 free(lostfound_ptr); 985 }
861 lostfound_ptr = lostfound_tmp; 986 }
862 } else { 987 }
863 lostfound_shd = lostfound_ptr; 988 } else {
864 lostfound_ptr = lostfound_ptr->next; 989 // this node contains node pointers
865 } 990 DEBUG_HEXDUMPC(buf, DESC_BLOCK_SIZE, ITEM_SIZE);
866 } 991 if (item_count > INDEX_COUNT_MAX) {
867 } 992 DEBUG_WARN(("Item count %i too large, max is %i\n", item_count, INDEX_COUNT_MAX));
868 } else { 993 if (buf) free(buf);
869 // this node contains node pointers 994 DEBUG_RET();
870 DEBUG_HEXDUMPC(buf, DESC_BLOCK_SIZE, ITEM_SIZE); 995 return -1;
871 if (item_count > INDEX_COUNT_MAX) { 996 }
872 DEBUG_WARN(("Item count %i too large, max is %i\n", item_count, INDEX_COUNT_MAX)); 997 x = 0;
873 if (buf) free(buf); 998 while (x < item_count) {
874 DEBUG_RET(); 999 bptr+=_pst_decode_table(&table, bptr);
875 return -1; 1000 x++;
876 } 1001 if (table.start == 0) break;
877 x = 0; 1002 if (x < item_count) {
878 while (x < item_count) { 1003 _pst_decode_table(&table2, bptr);
879 memcpy(&table, bptr, sizeof(table)); 1004 }
880 LE32_CPU(table.start); 1005 else {
881 LE32_CPU(table.u1); 1006 table2.start = end_val;
882 LE32_CPU(table.offset); 1007 }
883 bptr += sizeof(table); 1008 DEBUG_INDEX(("[%i] %i Descriptor Table [start id = %#x, u1 = %#x, offset = %#x, end id = %#x]\n",
884 x++; 1009 depth, x, table.start, table.u1, table.offset, table2.start));
885 if (table.start == 0) break; 1010 if ((table.start >= end_val) || (table.start < old)) {
886 if (x < item_count) { 1011 DEBUG_WARN(("This table isn't right. Must be corruption, or I got it wrong!\n"));
887 memcpy(&table2, bptr, sizeof(table)); 1012 if (buf) free(buf);
888 LE32_CPU(table2.start); 1013 DEBUG_RET();
889 } 1014 return -1;
890 else { 1015 }
891 table2.start = end_val; 1016 old = table.start;
892 } 1017 if (x == 1) { // first entry
893 DEBUG_INDEX(("[%i] %i Descriptor Table [start id = %#x, u1 = %#x, offset = %#x, end id = %#x]\n", 1018 if (start_val != -1 && table.start != start_val) {
894 depth, x, table.start, table.u1, table.offset, table2.start)); 1019 DEBUG_WARN(("This table isn't right. Must be corruption, or I got it wrong!\n"));
895 if ((table.start >= end_val) || (table.start < old)) { 1020 if (buf) free(buf);
896 DEBUG_WARN(("This table isn't right. Must be corruption, or I got it wrong!\n")); 1021 DEBUG_RET();
897 if (buf) free(buf); 1022 return -1;
898 DEBUG_RET(); 1023 }
899 return -1; 1024 }
900 } 1025 _pst_build_desc_ptr(pf, table.offset, depth+1, table.u1, high_id, table.start, table2.start);
901 old = table.start; 1026 }
902 if (x == 1) { // first entry 1027 }
903 if (start_val != -1 && table.start != start_val) { 1028 if (depth == 0) {
904 DEBUG_WARN(("This table isn't right. Must be corruption, or I got it wrong!\n")); 1029 // free the quick cache
905 if (buf) free(buf); 1030 while (cache_head) {
906 DEBUG_RET(); 1031 cache_ptr = cache_head->next;
907 return -1; 1032 free(cache_head);
908 } 1033 cache_head = cache_ptr;
909 } 1034 }
910 _pst_build_desc_ptr(pf, table.offset, depth+1, table.u1, high_id, table.start, table2.start); 1035 // free the lost and found
911 } 1036 while (lostfound_head) {
912 } 1037 lostfound_ptr = lostfound_head->next;
913 if (depth == 0) { 1038 WARN(("unused lost/found item with parent %d))", lostfound_head->parent));
914 // free the quick cache 1039 free(lostfound_head);
915 while (cache_head) { 1040 lostfound_head = lostfound_ptr;
916 cache_ptr = cache_head->next; 1041 }
917 free(cache_head); 1042 }
918 cache_head = cache_ptr; 1043 if (buf) free(buf);
919 } 1044 DEBUG_RET();
920 // free the lost and found 1045 return 0;
921 while (lostfound_head) {
922 lostfound_ptr = lostfound_head->next;
923 WARN(("unused lost/found item with parent %d))", lostfound_head->parent));
924 free(lostfound_head);
925 lostfound_head = lostfound_ptr;
926 }
927 }
928 if (buf) free(buf);
929 DEBUG_RET();
930 return 0;
931 } 1046 }
932 1047
933 1048
934 void* _pst_parse_item(pst_file *pf, pst_desc_ll *d_ptr) { 1049 void* _pst_parse_item(pst_file *pf, pst_desc_ll *d_ptr) {
935 pst_num_array * list; 1050 pst_num_array * list;
936 pst_index2_ll *id2_head = NULL; 1051 pst_index2_ll *id2_head = NULL;
937 pst_index_ll *id_ptr = NULL; 1052 pst_index_ll *id_ptr = NULL;
938 pst_item *item = NULL; 1053 pst_item *item = NULL;
939 pst_item_attach *attach = NULL; 1054 pst_item_attach *attach = NULL;
940 int x; 1055 int x;
941 DEBUG_ENT("_pst_parse_item"); 1056 DEBUG_ENT("_pst_parse_item");
942 if (!d_ptr) { 1057 if (!d_ptr) {
943 DEBUG_WARN(("you cannot pass me a NULL! I don't want it!\n")); 1058 DEBUG_WARN(("you cannot pass me a NULL! I don't want it!\n"));
944 DEBUG_RET(); 1059 DEBUG_RET();
945 return NULL; 1060 return NULL;
946 } 1061 }
947 1062
948 if (!d_ptr->desc) { 1063 if (!d_ptr->desc) {
949 DEBUG_WARN(("why is d_ptr->desc == NULL? I don't want to do anything else with this record\n")); 1064 DEBUG_WARN(("why is d_ptr->desc == NULL? I don't want to do anything else with this record\n"));
950 DEBUG_RET(); 1065 DEBUG_RET();
951 return NULL; 1066 return NULL;
952 } 1067 }
953 1068
954 if (d_ptr->list_index) { 1069 if (d_ptr->list_index) {
955 id2_head = _pst_build_id2(pf, d_ptr->list_index, NULL); 1070 id2_head = _pst_build_id2(pf, d_ptr->list_index, NULL);
956 _pst_printID2ptr(id2_head); 1071 _pst_printID2ptr(id2_head);
957 } else { 1072 } else {
958 DEBUG_WARN(("Have not been able to fetch any id2 values for this item. Brace yourself!\n")); 1073 DEBUG_WARN(("Have not been able to fetch any id2 values for this item. Brace yourself!\n"));
959 } 1074 }
960 1075
961 list = _pst_parse_block(pf, d_ptr->desc->id, id2_head); 1076 list = _pst_parse_block(pf, d_ptr->desc->id, id2_head);
962 if (!list) { 1077 if (!list) {
963 DEBUG_WARN(("_pst_parse_block() returned an error for d_ptr->desc->id [%#x]\n", d_ptr->desc->id)); 1078 DEBUG_WARN(("_pst_parse_block() returned an error for d_ptr->desc->id [%#x]\n", d_ptr->desc->id));
964 if (id2_head) _pst_free_id2(id2_head); 1079 if (id2_head) _pst_free_id2(id2_head);
965 DEBUG_RET(); 1080 DEBUG_RET();
966 return NULL; 1081 return NULL;
967 } 1082 }
968 1083
969 item = (pst_item*) xmalloc(sizeof(pst_item)); 1084 item = (pst_item*) xmalloc(sizeof(pst_item));
970 memset(item, 0, sizeof(pst_item)); 1085 memset(item, 0, sizeof(pst_item));
971 1086
972 if (_pst_process(list, item, NULL)) { 1087 if (_pst_process(list, item, NULL)) {
973 DEBUG_WARN(("_pst_process() returned non-zero value. That is an error\n")); 1088 DEBUG_WARN(("_pst_process() returned non-zero value. That is an error\n"));
974 if (item) _pst_freeItem(item); 1089 if (item) _pst_freeItem(item);
975 if (list) _pst_free_list(list); 1090 if (list) _pst_free_list(list);
976 if (id2_head) _pst_free_id2(id2_head); 1091 if (id2_head) _pst_free_id2(id2_head);
977 DEBUG_RET(); 1092 DEBUG_RET();
978 return NULL; 1093 return NULL;
979 } 1094 }
980 if (list) _pst_free_list(list); 1095 if (list) _pst_free_list(list);
981 list = NULL; //_pst_process will free the items in the list 1096 list = NULL; //_pst_process will free the items in the list
982 1097
983 if ((id_ptr = _pst_getID2(id2_head, 0x671))) { 1098 if ((id_ptr = _pst_getID2(id2_head, 0x671))) {
984 // attachments exist - so we will process them 1099 // attachments exist - so we will process them
985 while (item->attach) { 1100 while (item->attach) {
986 attach = item->attach->next; 1101 attach = item->attach->next;
987 free(item->attach); 1102 free(item->attach);
988 item->attach = attach; 1103 item->attach = attach;
989 } 1104 }
990 1105
991 DEBUG_EMAIL(("ATTACHMENT processing attachment\n")); 1106 DEBUG_EMAIL(("ATTACHMENT processing attachment\n"));
992 if ((list = _pst_parse_block(pf, id_ptr->id, id2_head)) == NULL) { 1107 if ((list = _pst_parse_block(pf, id_ptr->id, id2_head)) == NULL) {
993 DEBUG_WARN(("ERROR error processing main attachment record\n")); 1108 DEBUG_WARN(("ERROR error processing main attachment record\n"));
994 if (item) _pst_freeItem(item); 1109 if (item) _pst_freeItem(item);
995 if (id2_head) _pst_free_id2(id2_head); 1110 if (id2_head) _pst_free_id2(id2_head);
996 DEBUG_RET(); 1111 DEBUG_RET();
997 return NULL; 1112 return NULL;
998 } 1113 }
999 else { 1114 else {
1000 x = 0; 1115 x = 0;
1001 while (x < list->count_array) { 1116 while (x < list->count_array) {
1002 attach = (pst_item_attach*) xmalloc (sizeof(pst_item_attach)); 1117 attach = (pst_item_attach*) xmalloc (sizeof(pst_item_attach));
1003 memset (attach, 0, sizeof(pst_item_attach)); 1118 memset (attach, 0, sizeof(pst_item_attach));
1004 attach->next = item->attach; 1119 attach->next = item->attach;
1005 item->attach = attach; 1120 item->attach = attach;
1006 x++; 1121 x++;
1007 } 1122 }
1008 1123
1009 if (_pst_process(list, item, item->attach)) { 1124 if (_pst_process(list, item, item->attach)) {
1010 DEBUG_WARN(("ERROR _pst_process() failed with attachments\n")); 1125 DEBUG_WARN(("ERROR _pst_process() failed with attachments\n"));
1011 if (item) _pst_freeItem(item); 1126 if (item) _pst_freeItem(item);
1012 if (list) _pst_free_list(list); 1127 if (list) _pst_free_list(list);
1013 if (id2_head) _pst_free_id2(id2_head); 1128 if (id2_head) _pst_free_id2(id2_head);
1014 DEBUG_RET(); 1129 DEBUG_RET();
1015 return NULL; 1130 return NULL;
1016 } 1131 }
1017 if (list) _pst_free_list(list); 1132 if (list) _pst_free_list(list);
1018 list = NULL; 1133 list = NULL;
1019 1134
1020 // now we will have initial information of each attachment stored in item->attach... 1135 // now we will have initial information of each attachment stored in item->attach...
1021 // we must now read the secondary record for each based on the id2 val associated with 1136 // we must now read the secondary record for each based on the id2 val associated with
1022 // each attachment 1137 // each attachment
1023 attach = item->attach; 1138 attach = item->attach;
1024 while (attach) { 1139 while (attach) {
1025 if ((id_ptr = _pst_getID2(id2_head, attach->id2_val))) { 1140 if ((id_ptr = _pst_getID2(id2_head, attach->id2_val))) {
1026 // id_ptr is a record describing the attachment 1141 // id_ptr is a record describing the attachment
1027 // we pass NULL instead of id2_head cause we don't want it to 1142 // we pass NULL instead of id2_head cause we don't want it to
1028 // load all the extra stuff here. 1143 // load all the extra stuff here.
1029 if ((list = _pst_parse_block(pf, id_ptr->id, NULL)) == NULL) { 1144 if ((list = _pst_parse_block(pf, id_ptr->id, NULL)) == NULL) {
1030 DEBUG_WARN(("ERROR error processing an attachment record\n")); 1145 DEBUG_WARN(("ERROR error processing an attachment record\n"));
1031 attach = attach->next; 1146 attach = attach->next;
1032 continue; 1147 continue;
1033 } 1148 }
1034 if (_pst_process(list, item, attach)) { 1149 if (_pst_process(list, item, attach)) {
1035 DEBUG_WARN(("ERROR _pst_process() failed with an attachment\n")); 1150 DEBUG_WARN(("ERROR _pst_process() failed with an attachment\n"));
1036 if (list) _pst_free_list(list); 1151 if (list) _pst_free_list(list);
1037 list = NULL; 1152 list = NULL;
1038 attach = attach->next; 1153 attach = attach->next;
1039 continue; 1154 continue;
1040 } 1155 }
1041 if (list) _pst_free_list(list); 1156 if (list) _pst_free_list(list);
1042 list = NULL; 1157 list = NULL;
1043 id_ptr = _pst_getID2(id2_head, attach->id2_val); 1158 id_ptr = _pst_getID2(id2_head, attach->id2_val);
1044 if (id_ptr) { 1159 if (id_ptr) {
1045 // id2_val has been updated to the ID2 value of the datablock containing the 1160 // id2_val has been updated to the ID2 value of the datablock containing the
1046 // attachment data 1161 // attachment data
1047 attach->id_val = id_ptr->id; 1162 attach->id_val = id_ptr->id;
1048 } else { 1163 } else {
1049 DEBUG_WARN(("have not located the correct value for the attachment [%#x]\n", attach->id2_val)); 1164 DEBUG_WARN(("have not located the correct value for the attachment [%#x]\n", attach->id2_val));
1050 } 1165 }
1051 } else { 1166 } else {
1052 DEBUG_WARN(("ERROR cannot locate id2 value %#x\n", attach->id2_val)); 1167 DEBUG_WARN(("ERROR cannot locate id2 value %#x\n", attach->id2_val));
1053 } 1168 }
1054 attach = attach->next; 1169 attach = attach->next;
1055 } 1170 }
1056 } 1171 }
1057 } 1172 }
1058 1173
1059 _pst_free_id2(id2_head); 1174 _pst_free_id2(id2_head);
1060 id2_head = NULL; 1175 id2_head = NULL;
1061 DEBUG_RET(); 1176 DEBUG_RET();
1062 return item; 1177 return item;
1063 } 1178 }
1064 1179
1065 1180
1066 void freeall(unsigned char *buf, pst_block_offset_pointer *p1, 1181 void freeall(unsigned char *buf, pst_block_offset_pointer *p1,
1067 pst_block_offset_pointer *p2, 1182 pst_block_offset_pointer *p2,
1068 pst_block_offset_pointer *p3, 1183 pst_block_offset_pointer *p3,
1069 pst_block_offset_pointer *p4, 1184 pst_block_offset_pointer *p4,
1070 pst_block_offset_pointer *p5, 1185 pst_block_offset_pointer *p5,
1071 pst_block_offset_pointer *p6, 1186 pst_block_offset_pointer *p6,
1072 pst_block_offset_pointer *p7) { 1187 pst_block_offset_pointer *p7) {
1073 if (buf) free(buf); 1188 if (buf) free(buf);
1074 if (p1->needfree) free(p1->from); 1189 if (p1->needfree) free(p1->from);
1075 if (p2->needfree) free(p2->from); 1190 if (p2->needfree) free(p2->from);
1076 if (p3->needfree) free(p3->from); 1191 if (p3->needfree) free(p3->from);
1077 if (p4->needfree) free(p4->from); 1192 if (p4->needfree) free(p4->from);
1078 if (p5->needfree) free(p5->from); 1193 if (p5->needfree) free(p5->from);
1079 if (p6->needfree) free(p6->from); 1194 if (p6->needfree) free(p6->from);
1080 if (p7->needfree) free(p7->from); 1195 if (p7->needfree) free(p7->from);
1081 } 1196 }
1082 1197
1083 1198
1084 pst_num_array * _pst_parse_block(pst_file *pf, u_int32_t block_id, pst_index2_ll *i2_head) { 1199 pst_num_array * _pst_parse_block(pst_file *pf, uint32_t block_id, pst_index2_ll *i2_head) {
1085 unsigned char *buf = NULL; 1200 unsigned char *buf = NULL;
1086 pst_num_array *na_ptr = NULL, *na_head = NULL; 1201 pst_num_array *na_ptr = NULL, *na_head = NULL;
1087 pst_block_offset_pointer block_offset1; 1202 pst_block_offset_pointer block_offset1;
1088 pst_block_offset_pointer block_offset2; 1203 pst_block_offset_pointer block_offset2;
1089 pst_block_offset_pointer block_offset3; 1204 pst_block_offset_pointer block_offset3;
1090 pst_block_offset_pointer block_offset4; 1205 pst_block_offset_pointer block_offset4;
1091 pst_block_offset_pointer block_offset5; 1206 pst_block_offset_pointer block_offset5;
1092 pst_block_offset_pointer block_offset6; 1207 pst_block_offset_pointer block_offset6;
1093 pst_block_offset_pointer block_offset7; 1208 pst_block_offset_pointer block_offset7;
1094 u_int32_t size; 1209 uint32_t size;
1095 u_int32_t x; 1210 uint32_t x;
1096 u_int32_t num_recs; 1211 uint32_t num_recs;
1097 u_int32_t count_rec; 1212 uint32_t count_rec;
1098 u_int32_t num_list; 1213 uint32_t num_list;
1099 u_int32_t cur_list; 1214 uint32_t cur_list;
1100 u_int32_t block_type; 1215 uint32_t block_type;
1101 u_int32_t rec_size = 0; 1216 uint32_t rec_size = 0;
1102 u_int32_t ind_ptr; 1217 uint32_t ind_ptr;
1103 unsigned char* list_start; 1218 unsigned char* list_start;
1104 unsigned char* t_ptr; 1219 unsigned char* t_ptr;
1105 unsigned char* fr_ptr; 1220 unsigned char* fr_ptr;
1106 unsigned char* to_ptr; 1221 unsigned char* to_ptr;
1107 unsigned char* ind2_end; 1222 unsigned char* ind2_end;
1108 unsigned char* ind2_ptr = NULL; 1223 unsigned char* ind2_ptr = NULL;
1109 size_t read_size=0; 1224 size_t read_size=0;
1110 pst_x_attrib_ll *mapptr; 1225 pst_x_attrib_ll *mapptr;
1111 1226
1112 struct { 1227 struct {
1113 u_int16_t type; 1228 uint16_t type;
1114 u_int16_t ref_type; 1229 uint16_t ref_type;
1115 u_int32_t value; 1230 uint32_t value;
1116 } table_rec; //for type 1 (0xBCEC) blocks 1231 } table_rec; //for type 1 (0xBCEC) blocks
1117 struct { 1232 struct {
1118 u_int16_t ref_type; 1233 uint16_t ref_type;
1119 u_int16_t type; 1234 uint16_t type;
1120 u_int16_t ind2_off; 1235 uint16_t ind2_off;
1121 u_int8_t size; 1236 uint8_t size;
1122 u_int8_t slot; 1237 uint8_t slot;
1123 } table2_rec; //for type 2 (0x7CEC) blocks 1238 } table2_rec; //for type 2 (0x7CEC) blocks
1124 struct { 1239 struct {
1125 u_int32_t id; 1240 uint32_t id;
1126 } table3_rec; //for type 3 (0x0101) blocks 1241 } table3_rec; //for type 3 (0x0101) blocks
1127 struct { 1242 struct {
1128 u_int16_t index_offset; 1243 uint16_t index_offset;
1129 u_int16_t type; 1244 uint16_t type;
1130 u_int32_t offset; 1245 uint32_t offset;
1131 } block_hdr; 1246 } block_hdr;
1132 struct { 1247 struct {
1133 unsigned char seven_c; 1248 unsigned char seven_c;
1134 unsigned char item_count; 1249 unsigned char item_count;
1135 u_int16_t u1; 1250 uint16_t u1;
1136 u_int16_t u2; 1251 uint16_t u2;
1137 u_int16_t u3; 1252 uint16_t u3;
1138 u_int16_t rec_size; 1253 uint16_t rec_size;
1139 u_int32_t b_five_offset; 1254 uint32_t b_five_offset;
1140 u_int32_t ind2_offset; 1255 uint32_t ind2_offset;
1141 u_int16_t u7; 1256 uint16_t u7;
1142 u_int16_t u8; 1257 uint16_t u8;
1143 } seven_c_blk; 1258 } seven_c_blk;
1144 struct _type_d_rec { 1259 struct _type_d_rec {
1145 u_int32_t id; 1260 uint32_t id;
1146 u_int32_t u1; 1261 uint32_t u1;
1147 } * type_d_rec; 1262 } * type_d_rec;
1148 1263
1149 DEBUG_ENT("_pst_parse_block"); 1264 DEBUG_ENT("_pst_parse_block");
1150 if ((read_size = _pst_ff_getIDblock_dec(pf, block_id, &buf)) == 0) { 1265 if ((read_size = _pst_ff_getIDblock_dec(pf, block_id, &buf)) == 0) {
1151 WARN(("Error reading block id %#x\n", block_id)); 1266 WARN(("Error reading block id %#x\n", block_id));
1152 if (buf) free (buf); 1267 if (buf) free (buf);
1153 DEBUG_RET(); 1268 DEBUG_RET();
1154 return NULL; 1269 return NULL;
1155 } 1270 }
1156 1271
1157 block_offset1.needfree = 0; 1272 block_offset1.needfree = 0;
1158 block_offset2.needfree = 0; 1273 block_offset2.needfree = 0;
1159 block_offset3.needfree = 0; 1274 block_offset3.needfree = 0;
1160 block_offset4.needfree = 0; 1275 block_offset4.needfree = 0;
1161 block_offset5.needfree = 0; 1276 block_offset5.needfree = 0;
1162 block_offset6.needfree = 0; 1277 block_offset6.needfree = 0;
1163 block_offset7.needfree = 0; 1278 block_offset7.needfree = 0;
1164 1279
1165 memcpy(&block_hdr, buf, sizeof(block_hdr)); 1280 memcpy(&block_hdr, buf, sizeof(block_hdr));
1166 LE16_CPU(block_hdr.index_offset); 1281 LE16_CPU(block_hdr.index_offset);
1167 LE16_CPU(block_hdr.type); 1282 LE16_CPU(block_hdr.type);
1168 LE32_CPU(block_hdr.offset); 1283 LE32_CPU(block_hdr.offset);
1169 DEBUG_EMAIL(("block header (index_offset=%#hx, type=%#hx, offset=%#hx\n", block_hdr.index_offset, block_hdr.type, block_hdr.offset)); 1284 DEBUG_EMAIL(("block header (index_offset=%#hx, type=%#hx, offset=%#hx\n", block_hdr.index_offset, block_hdr.type, block_hdr.offset));
1170 1285
1171 ind_ptr = block_hdr.index_offset; 1286 ind_ptr = block_hdr.index_offset;
1172 1287
1173 if (block_hdr.type == 0xBCEC) { //type 1 1288 if (block_hdr.type == 0xBCEC) { //type 1
1174 block_type = 1; 1289 block_type = 1;
1175 1290
1176 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, block_hdr.offset, &block_offset1)) { 1291 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, block_hdr.offset, &block_offset1)) {
1177 DEBUG_WARN(("internal error (bc.b5 offset %#x) in reading block id %#x\n", block_hdr.offset, block_id)); 1292 DEBUG_WARN(("internal error (bc.b5 offset %#x) in reading block id %#x\n", block_hdr.offset, block_id));
1178 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1293 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1179 DEBUG_RET(); 1294 DEBUG_RET();
1180 return NULL; 1295 return NULL;
1181 } 1296 }
1182 memcpy(&table_rec, block_offset1.from, sizeof(table_rec)); 1297 memcpy(&table_rec, block_offset1.from, sizeof(table_rec));
1183 LE16_CPU(table_rec.type); 1298 LE16_CPU(table_rec.type);
1184 LE16_CPU(table_rec.ref_type); 1299 LE16_CPU(table_rec.ref_type);
1185 LE32_CPU(table_rec.value); 1300 LE32_CPU(table_rec.value);
1186 DEBUG_EMAIL(("table_rec (type=%#hx, ref_type=%#hx, value=%#x)\n", table_rec.type, table_rec.ref_type, table_rec.value)); 1301 DEBUG_EMAIL(("table_rec (type=%#hx, ref_type=%#hx, value=%#x)\n", table_rec.type, table_rec.ref_type, table_rec.value));
1187 1302
1188 if (table_rec.type != 0x02B5) { 1303 if (table_rec.type != 0x02B5) {
1189 WARN(("Unknown second block constant - %#X for id %#x\n", table_rec.type, block_id)); 1304 WARN(("Unknown second block constant - %#X for id %#x\n", table_rec.type, block_id));
1190 DEBUG_HEXDUMPC(buf, sizeof(table_rec), 0x10); 1305 DEBUG_HEXDUMPC(buf, sizeof(table_rec), 0x10);
1191 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1306 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1192 DEBUG_RET(); 1307 DEBUG_RET();
1193 return NULL; 1308 return NULL;
1194 } 1309 }
1195 1310
1196 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, table_rec.value, &block_offset2)) { 1311 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, table_rec.value, &block_offset2)) {
1197 DEBUG_WARN(("internal error (bc.b5.desc offset) in reading block id %#x\n", table_rec.value, block_id)); 1312 DEBUG_WARN(("internal error (bc.b5.desc offset) in reading block id %#x\n", table_rec.value, block_id));
1198 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1313 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1199 DEBUG_RET(); 1314 DEBUG_RET();
1200 return NULL; 1315 return NULL;
1201 } 1316 }
1202 list_start = block_offset2.from; 1317 list_start = block_offset2.from;
1203 to_ptr = block_offset2.to; 1318 to_ptr = block_offset2.to;
1204 num_list = (to_ptr - list_start)/sizeof(table_rec); 1319 num_list = (to_ptr - list_start)/sizeof(table_rec);
1205 num_recs = 1; // only going to be one object in these blocks 1320 num_recs = 1; // only going to be one object in these blocks
1206 } 1321 }
1207 else if (block_hdr.type == 0x7CEC) { //type 2 1322 else if (block_hdr.type == 0x7CEC) { //type 2
1208 block_type = 2; 1323 block_type = 2;
1209 1324
1210 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, block_hdr.offset, &block_offset3)) { 1325 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, block_hdr.offset, &block_offset3)) {
1211 DEBUG_WARN(("internal error (7c.7c offset %#x) in reading block id %#x\n", block_hdr.offset, block_id)); 1326 DEBUG_WARN(("internal error (7c.7c offset %#x) in reading block id %#x\n", block_hdr.offset, block_id));
1212 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1327 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1213 DEBUG_RET(); 1328 DEBUG_RET();
1214 return NULL; 1329 return NULL;
1215 } 1330 }
1216 fr_ptr = block_offset3.from; //now got pointer to "7C block" 1331 fr_ptr = block_offset3.from; //now got pointer to "7C block"
1217 memset(&seven_c_blk, 0, sizeof(seven_c_blk)); 1332 memset(&seven_c_blk, 0, sizeof(seven_c_blk));
1218 memcpy(&seven_c_blk, fr_ptr, sizeof(seven_c_blk)); 1333 memcpy(&seven_c_blk, fr_ptr, sizeof(seven_c_blk));
1219 LE16_CPU(seven_c_blk.u1); 1334 LE16_CPU(seven_c_blk.u1);
1220 LE16_CPU(seven_c_blk.u2); 1335 LE16_CPU(seven_c_blk.u2);
1221 LE16_CPU(seven_c_blk.u3); 1336 LE16_CPU(seven_c_blk.u3);
1222 LE16_CPU(seven_c_blk.rec_size); 1337 LE16_CPU(seven_c_blk.rec_size);
1223 LE32_CPU(seven_c_blk.b_five_offset); 1338 LE32_CPU(seven_c_blk.b_five_offset);
1224 LE32_CPU(seven_c_blk.ind2_offset); 1339 LE32_CPU(seven_c_blk.ind2_offset);
1225 LE16_CPU(seven_c_blk.u7); 1340 LE16_CPU(seven_c_blk.u7);
1226 LE16_CPU(seven_c_blk.u8); 1341 LE16_CPU(seven_c_blk.u8);
1227 1342
1228 list_start = fr_ptr + sizeof(seven_c_blk); // the list of item numbers start after this record 1343 list_start = fr_ptr + sizeof(seven_c_blk); // the list of item numbers start after this record
1229 1344
1230 if (seven_c_blk.seven_c != 0x7C) { // this would mean it isn't a 7C block! 1345 if (seven_c_blk.seven_c != 0x7C) { // this would mean it isn't a 7C block!
1231 WARN(("Error. There isn't a 7C where I want to see 7C!\n")); 1346 WARN(("Error. There isn't a 7C where I want to see 7C!\n"));
1232 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1347 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1233 DEBUG_RET(); 1348 DEBUG_RET();
1234 return NULL; 1349 return NULL;
1235 } 1350 }
1236 1351
1237 rec_size = seven_c_blk.rec_size; 1352 rec_size = seven_c_blk.rec_size;
1238 num_list = seven_c_blk.item_count; 1353 num_list = seven_c_blk.item_count;
1239 1354
1240 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, seven_c_blk.b_five_offset, &block_offset4)) { 1355 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, seven_c_blk.b_five_offset, &block_offset4)) {
1241 DEBUG_WARN(("internal error (7c.b5 offset %#x) in reading block id %#x\n", seven_c_blk.b_five_offset, block_id)); 1356 DEBUG_WARN(("internal error (7c.b5 offset %#x) in reading block id %#x\n", seven_c_blk.b_five_offset, block_id));
1242 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1357 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1243 DEBUG_RET(); 1358 DEBUG_RET();
1244 return NULL; 1359 return NULL;
1245 } 1360 }
1246 memcpy(&table_rec, block_offset4.from, sizeof(table_rec)); 1361 memcpy(&table_rec, block_offset4.from, sizeof(table_rec));
1247 LE16_CPU(table_rec.type); 1362 LE16_CPU(table_rec.type);
1248 LE16_CPU(table_rec.ref_type); 1363 LE16_CPU(table_rec.ref_type);
1249 LE32_CPU(table_rec.value); 1364 LE32_CPU(table_rec.value);
1250 1365
1251 if (table_rec.type != 0x04B5) { // different constant than a type 1 record 1366 if (table_rec.type != 0x04B5) { // different constant than a type 1 record
1252 WARN(("Unknown second block constant - %#X for id %#x\n", table_rec.type, block_id)); 1367 WARN(("Unknown second block constant - %#X for id %#x\n", table_rec.type, block_id));
1253 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1368 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1254 DEBUG_RET(); 1369 DEBUG_RET();
1255 return NULL; 1370 return NULL;
1256 } 1371 }
1257 1372
1258 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, table_rec.value, &block_offset5)) { 1373 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, table_rec.value, &block_offset5)) {
1259 DEBUG_WARN(("internal error (7c.5b.desc offset %#x) in reading block id %#x\n", table_rec.value, block_id)); 1374 DEBUG_WARN(("internal error (7c.5b.desc offset %#x) in reading block id %#x\n", table_rec.value, block_id));
1260 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1375 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1261 DEBUG_RET(); 1376 DEBUG_RET();
1262 return NULL; 1377 return NULL;
1263 } 1378 }
1264 num_recs = (block_offset5.to - block_offset5.from) / 6; // this will give the number of records in this block 1379 num_recs = (block_offset5.to - block_offset5.from) / 6; // this will give the number of records in this block
1265 1380
1266 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, seven_c_blk.ind2_offset, &block_offset6)) { 1381 if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, seven_c_blk.ind2_offset, &block_offset6)) {
1267 DEBUG_WARN(("internal error (7c.ind2 offset %#x) in reading block id %#x\n", seven_c_blk.ind2_offset, block_id)); 1382 DEBUG_WARN(("internal error (7c.ind2 offset %#x) in reading block id %#x\n", seven_c_blk.ind2_offset, block_id));
1268 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1383 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1269 DEBUG_RET(); 1384 DEBUG_RET();
1270 return NULL; 1385 return NULL;
1271 } 1386 }
1272 ind2_ptr = block_offset6.from; 1387 ind2_ptr = block_offset6.from;
1273 ind2_end = block_offset6.to; 1388 ind2_end = block_offset6.to;
1274 } 1389 }
1275 else if (block_hdr.index_offset == 0x0101) { //type 2 1390 else if (block_hdr.index_offset == 0x0101) { //type 2
1276 unsigned char *buf2 = NULL; 1391 unsigned char *buf2 = NULL;
1277 int n = block_hdr.type; // count 1392 int n = block_hdr.type; // count
1278 int m = sizeof(table3_rec); 1393 int m = sizeof(table3_rec);
1279 int i; 1394 int i;
1280 block_type = 3; 1395 block_type = 3;
1281 for (i=0; i<n; i++) { 1396 for (i=0; i<n; i++) {
1282 memcpy(&table3_rec, buf+8+i*m, m); 1397 memcpy(&table3_rec, buf+8+i*m, m);
1283 LE32_CPU(table3_rec.id); 1398 LE32_CPU(table3_rec.id);
1284 _pst_ff_getIDblock_dec(pf, table3_rec.id, &buf2); 1399 _pst_ff_getIDblock_dec(pf, table3_rec.id, &buf2);
1285 if (buf2) free(buf2); 1400 if (buf2) free(buf2);
1286 buf2 = NULL; 1401 buf2 = NULL;
1287 } 1402 }
1288 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1403 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1289 DEBUG_RET(); 1404 DEBUG_RET();
1290 return NULL; 1405 return NULL;
1291 } else { 1406 } else {
1292 WARN(("ERROR: Unknown block constant - %#X for id %#x\n", block_hdr.type, block_id)); 1407 WARN(("ERROR: Unknown block constant - %#X for id %#x\n", block_hdr.type, block_id));
1293 DEBUG_HEXDUMPC(buf, read_size,0x10); 1408 DEBUG_HEXDUMPC(buf, read_size,0x10);
1294 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1409 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1295 DEBUG_RET(); 1410 DEBUG_RET();
1296 return NULL; 1411 return NULL;
1297 } 1412 }
1298 1413
1299 DEBUG_EMAIL(("Mallocing number of records %i\n", num_recs)); 1414 DEBUG_EMAIL(("Mallocing number of records %i\n", num_recs));
1300 for (count_rec=0; count_rec<num_recs; count_rec++) { 1415 for (count_rec=0; count_rec<num_recs; count_rec++) {
1301 na_ptr = (pst_num_array*) xmalloc(sizeof(pst_num_array)); 1416 na_ptr = (pst_num_array*) xmalloc(sizeof(pst_num_array));
1302 memset(na_ptr, 0, sizeof(pst_num_array)); 1417 memset(na_ptr, 0, sizeof(pst_num_array));
1303 na_ptr->next = na_head; 1418 na_ptr->next = na_head;
1304 na_head = na_ptr; 1419 na_head = na_ptr;
1305 // allocate an array of count num_recs to contain sizeof(struct_pst_num_item) 1420 // allocate an array of count num_recs to contain sizeof(struct_pst_num_item)
1306 na_ptr->items = (struct _pst_num_item**) xmalloc(sizeof(struct _pst_num_item)*num_list); 1421 na_ptr->items = (struct _pst_num_item**) xmalloc(sizeof(struct _pst_num_item)*num_list);
1307 na_ptr->count_item = num_list; 1422 na_ptr->count_item = num_list;
1308 na_ptr->orig_count = num_list; 1423 na_ptr->orig_count = num_list;
1309 na_ptr->count_array = num_recs; // each record will have a record of the total number of records 1424 na_ptr->count_array = num_recs; // each record will have a record of the total number of records
1310 for (x=0; x<num_list; x++) na_ptr->items[x] = NULL; 1425 for (x=0; x<num_list; x++) na_ptr->items[x] = NULL;
1311 x = 0; 1426 x = 0;
1312 1427
1313 DEBUG_EMAIL(("going to read %i (%#x) items\n", na_ptr->count_item, na_ptr->count_item)); 1428 DEBUG_EMAIL(("going to read %i (%#x) items\n", na_ptr->count_item, na_ptr->count_item));
1314 1429
1315 fr_ptr = list_start; // initialize fr_ptr to the start of the list. 1430 fr_ptr = list_start; // initialize fr_ptr to the start of the list.
1316 for (cur_list=0; cur_list<num_list; cur_list++) { //we will increase fr_ptr as we progress through index 1431 for (cur_list=0; cur_list<num_list; cur_list++) { //we will increase fr_ptr as we progress through index
1317 unsigned char* value_pointer = NULL; // needed for block type 2 with values larger than 4 bytes 1432 unsigned char* value_pointer = NULL; // needed for block type 2 with values larger than 4 bytes
1318 int value_size = 0; 1433 int value_size = 0;
1319 if (block_type == 1) { 1434 if (block_type == 1) {
1320 memcpy(&table_rec, fr_ptr, sizeof(table_rec)); 1435 memcpy(&table_rec, fr_ptr, sizeof(table_rec));
1321 LE16_CPU(table_rec.type); 1436 LE16_CPU(table_rec.type);
1322 LE16_CPU(table_rec.ref_type); 1437 LE16_CPU(table_rec.ref_type);
1323 //LE32_CPU(table_rec.value); // done later, some may be order invariant 1438 //LE32_CPU(table_rec.value); // done later, some may be order invariant
1324 fr_ptr += sizeof(table_rec); 1439 fr_ptr += sizeof(table_rec);
1325 } else if (block_type == 2) { 1440 } else if (block_type == 2) {
1326 // we will copy the table2_rec values into a table_rec record so that we can keep the rest of the code 1441 // we will copy the table2_rec values into a table_rec record so that we can keep the rest of the code
1327 memcpy(&table2_rec, fr_ptr, sizeof(table2_rec)); 1442 memcpy(&table2_rec, fr_ptr, sizeof(table2_rec));
1328 LE16_CPU(table2_rec.ref_type); 1443 LE16_CPU(table2_rec.ref_type);
1329 LE16_CPU(table2_rec.type); 1444 LE16_CPU(table2_rec.type);
1330 LE16_CPU(table2_rec.ind2_off); 1445 LE16_CPU(table2_rec.ind2_off);
1331 1446
1332 // table_rec and table2_rec are arranged differently, so assign the values across 1447 // table_rec and table2_rec are arranged differently, so assign the values across
1333 table_rec.type = table2_rec.type; 1448 table_rec.type = table2_rec.type;
1334 table_rec.ref_type = table2_rec.ref_type; 1449 table_rec.ref_type = table2_rec.ref_type;
1335 table_rec.value = 0; 1450 table_rec.value = 0;
1336 if ((ind2_end - ind2_ptr) >= (table2_rec.ind2_off + table2_rec.size)) { 1451 if ((ind2_end - ind2_ptr) >= (table2_rec.ind2_off + table2_rec.size)) {
1337 int n = table2_rec.size; 1452 int n = table2_rec.size;
1338 int m = sizeof(table_rec.value); 1453 int m = sizeof(table_rec.value);
1339 if (n <= m) { 1454 if (n <= m) {
1340 memcpy(&table_rec.value, ind2_ptr + table2_rec.ind2_off, n); 1455 memcpy(&table_rec.value, ind2_ptr + table2_rec.ind2_off, n);
1341 } 1456 }
1342 else { 1457 else {
1343 value_pointer = ind2_ptr + table2_rec.ind2_off; 1458 value_pointer = ind2_ptr + table2_rec.ind2_off;
1344 value_size = n; 1459 value_size = n;
1345 } 1460 }
1346 //LE32_CPU(table_rec.value); // done later, some may be order invariant 1461 //LE32_CPU(table_rec.value); // done later, some may be order invariant
1347 } 1462 }
1348 else { 1463 else {
1349 DEBUG_WARN (("Trying to read outside buffer, buffer size %#x, offset %#x, data size %#x\n", 1464 DEBUG_WARN (("Trying to read outside buffer, buffer size %#x, offset %#x, data size %#x\n",
1350 read_size, ind2_end-ind2_ptr+table2_rec.ind2_off, table2_rec.size)); 1465 read_size, ind2_end-ind2_ptr+table2_rec.ind2_off, table2_rec.size));
1351 } 1466 }
1352 fr_ptr += sizeof(table2_rec); 1467 fr_ptr += sizeof(table2_rec);
1353 } else { 1468 } else {
1354 WARN(("Missing code for block_type %i\n", block_type)); 1469 WARN(("Missing code for block_type %i\n", block_type));
1355 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1470 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1356 if (na_head) _pst_free_list(na_head); 1471 if (na_head) _pst_free_list(na_head);
1357 DEBUG_RET(); 1472 DEBUG_RET();
1358 return NULL; 1473 return NULL;
1359 } 1474 }
1360 DEBUG_EMAIL(("reading block %i (type=%#x, ref_type=%#x, value=%#x)\n", 1475 DEBUG_EMAIL(("reading block %i (type=%#x, ref_type=%#x, value=%#x)\n",
1361 x, table_rec.type, table_rec.ref_type, table_rec.value)); 1476 x, table_rec.type, table_rec.ref_type, table_rec.value));
1362 1477
1363 if (!na_ptr->items[x]) { 1478 if (!na_ptr->items[x]) {
1364 na_ptr->items[x] = (struct _pst_num_item*) xmalloc(sizeof(struct _pst_num_item)); 1479 na_ptr->items[x] = (struct _pst_num_item*) xmalloc(sizeof(struct _pst_num_item));
1365 } 1480 }
1366 memset(na_ptr->items[x], 0, sizeof(struct _pst_num_item)); //init it 1481 memset(na_ptr->items[x], 0, sizeof(struct _pst_num_item)); //init it
1367 1482
1368 // check here to see if the id of the attribute is a mapped one 1483 // check here to see if the id of the attribute is a mapped one
1369 mapptr = pf->x_head; 1484 mapptr = pf->x_head;
1370 while (mapptr && (mapptr->map < table_rec.type)) mapptr = mapptr->next; 1485 while (mapptr && (mapptr->map < table_rec.type)) mapptr = mapptr->next;
1371 if (mapptr && (mapptr->map == table_rec.type)) { 1486 if (mapptr && (mapptr->map == table_rec.type)) {
1372 if (mapptr->mytype == PST_MAP_ATTRIB) { 1487 if (mapptr->mytype == PST_MAP_ATTRIB) {
1373 na_ptr->items[x]->id = *((int*)mapptr->data); 1488 na_ptr->items[x]->id = *((int*)mapptr->data);
1374 DEBUG_EMAIL(("Mapped attrib %#x to %#x\n", table_rec.type, na_ptr->items[x]->id)); 1489 DEBUG_EMAIL(("Mapped attrib %#x to %#x\n", table_rec.type, na_ptr->items[x]->id));
1375 } else if (mapptr->mytype == PST_MAP_HEADER) { 1490 } else if (mapptr->mytype == PST_MAP_HEADER) {
1376 DEBUG_EMAIL(("Internet Header mapping found %#x\n", table_rec.type)); 1491 DEBUG_EMAIL(("Internet Header mapping found %#x\n", table_rec.type));
1377 na_ptr->items[x]->id = PST_ATTRIB_HEADER; 1492 na_ptr->items[x]->id = PST_ATTRIB_HEADER;
1378 na_ptr->items[x]->extra = mapptr->data; 1493 na_ptr->items[x]->extra = mapptr->data;
1379 } 1494 }
1380 } else { 1495 } else {
1381 na_ptr->items[x]->id = table_rec.type; 1496 na_ptr->items[x]->id = table_rec.type;
1382 } 1497 }
1383 na_ptr->items[x]->type = 0; // checked later before it is set 1498 na_ptr->items[x]->type = 0; // checked later before it is set
1384 /* Reference Types 1499 /* Reference Types
1385 0x0002 - Signed 16bit value 1500 0x0002 - Signed 16bit value
1386 0x0003 - Signed 32bit value 1501 0x0003 - Signed 32bit value
1387 0x0004 - 4-byte floating point 1502 0x0004 - 4-byte floating point
1388 0x0005 - Floating point double 1503 0x0005 - Floating point double
1389 0x0006 - Signed 64-bit int 1504 0x0006 - Signed 64-bit int
1390 0x0007 - Application Time 1505 0x0007 - Application Time
1391 0x000A - 32-bit error value 1506 0x000A - 32-bit error value
1392 0x000B - Boolean (non-zero = true) 1507 0x000B - Boolean (non-zero = true)
1393 0x000D - Embedded Object 1508 0x000D - Embedded Object
1394 0x0014 - 8-byte signed integer (64-bit) 1509 0x0014 - 8-byte signed integer (64-bit)
1395 0x001E - Null terminated String 1510 0x001E - Null terminated String
1396 0x001F - Unicode string 1511 0x001F - Unicode string
1397 0x0040 - Systime - Filetime structure 1512 0x0040 - Systime - Filetime structure
1398 0x0048 - OLE Guid 1513 0x0048 - OLE Guid
1399 0x0102 - Binary data 1514 0x0102 - Binary data
1400 0x1003 - Array of 32bit values 1515 0x1003 - Array of 32bit values
1401 0x1014 - Array of 64bit values 1516 0x1014 - Array of 64bit values
1402 0x101E - Array of Strings 1517 0x101E - Array of Strings
1403 0x1102 - Array of Binary data 1518 0x1102 - Array of Binary data
1404 */ 1519 */
1405 1520
1406 if (table_rec.ref_type == 0x0002 || 1521 if (table_rec.ref_type == 0x0002 ||
1407 table_rec.ref_type == 0x0003 || 1522 table_rec.ref_type == 0x0003 ||
1408 table_rec.ref_type == 0x000b) { 1523 table_rec.ref_type == 0x000b) {
1409 //contains 32 bits of data 1524 //contains 32 bits of data
1410 na_ptr->items[x]->size = sizeof(int32_t); 1525 na_ptr->items[x]->size = sizeof(int32_t);
1411 na_ptr->items[x]->type = table_rec.ref_type; 1526 na_ptr->items[x]->type = table_rec.ref_type;
1412 na_ptr->items[x]->data = xmalloc(sizeof(int32_t)); 1527 na_ptr->items[x]->data = xmalloc(sizeof(int32_t));
1413 memcpy(na_ptr->items[x]->data, &(table_rec.value), sizeof(int32_t)); 1528 memcpy(na_ptr->items[x]->data, &(table_rec.value), sizeof(int32_t));
1414 1529
1415 } else if (table_rec.ref_type == 0x0005 || 1530 } else if (table_rec.ref_type == 0x0005 ||
1416 table_rec.ref_type == 0x000d || 1531 table_rec.ref_type == 0x000d ||
1417 table_rec.ref_type == 0x0014 || 1532 table_rec.ref_type == 0x0014 ||
1418 table_rec.ref_type == 0x001e || 1533 table_rec.ref_type == 0x001e ||
1419 table_rec.ref_type == 0x0040 || 1534 table_rec.ref_type == 0x001f ||
1420 table_rec.ref_type == 0x0048 || 1535 table_rec.ref_type == 0x0040 ||
1421 table_rec.ref_type == 0x0102 || 1536 table_rec.ref_type == 0x0048 ||
1422 table_rec.ref_type == 0x1003 || 1537 table_rec.ref_type == 0x0102 ||
1423 table_rec.ref_type == 0x1014 || 1538 table_rec.ref_type == 0x1003 ||
1424 table_rec.ref_type == 0x101e || 1539 table_rec.ref_type == 0x1014 ||
1425 table_rec.ref_type == 0x1102) { 1540 table_rec.ref_type == 0x101e ||
1426 //contains index reference to data 1541 table_rec.ref_type == 0x1102) {
1427 LE32_CPU(table_rec.value); 1542 //contains index reference to data
1428 if (value_pointer) { 1543 LE32_CPU(table_rec.value);
1429 // in a type 2 block, with a value that is more than 4 bytes 1544 if (value_pointer) {
1430 // directly stored in this block. 1545 // in a type 2 block, with a value that is more than 4 bytes
1431 na_ptr->items[x]->size = value_size; 1546 // directly stored in this block.
1432 na_ptr->items[x]->type = table_rec.ref_type; 1547 na_ptr->items[x]->size = value_size;
1433 na_ptr->items[x]->data = xmalloc(value_size); 1548 na_ptr->items[x]->type = table_rec.ref_type;
1434 memcpy(na_ptr->items[x]->data, value_pointer, value_size); 1549 na_ptr->items[x]->data = xmalloc(value_size);
1435 } 1550 memcpy(na_ptr->items[x]->data, value_pointer, value_size);
1436 else if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, table_rec.value, &block_offset7)) { 1551 }
1437 if ((table_rec.value & 0xf) == 0xf) { 1552 else if (_pst_getBlockOffsetPointer(pf, i2_head, buf, read_size, ind_ptr, table_rec.value, &block_offset7)) {
1438 DEBUG_WARN(("failed to get block offset for table_rec.value of %#x to be read later.\n", table_rec.value)); 1553 if ((table_rec.value & 0xf) == 0xf) {
1439 na_ptr->items[x]->size = 0; 1554 DEBUG_WARN(("failed to get block offset for table_rec.value of %#x to be read later.\n", table_rec.value));
1440 na_ptr->items[x]->data = NULL; 1555 na_ptr->items[x]->size = 0;
1441 na_ptr->items[x]->type = table_rec.value; 1556 na_ptr->items[x]->data = NULL;
1442 } 1557 na_ptr->items[x]->type = table_rec.value;
1443 else { 1558 }
1444 if (table_rec.value) { 1559 else {
1445 DEBUG_WARN(("failed to get block offset for table_rec.value of %#x\n", table_rec.value)); 1560 if (table_rec.value) {
1446 } 1561 DEBUG_WARN(("failed to get block offset for table_rec.value of %#x\n", table_rec.value));
1447 na_ptr->count_item --; //we will be skipping a row 1562 }
1448 continue; 1563 na_ptr->count_item --; //we will be skipping a row
1449 } 1564 continue;
1450 } 1565 }
1451 else { 1566 }
1452 value_size = block_offset7.to - block_offset7.from; 1567 else {
1453 na_ptr->items[x]->size = value_size; 1568 value_size = block_offset7.to - block_offset7.from;
1454 na_ptr->items[x]->type = table_rec.ref_type; 1569 na_ptr->items[x]->size = value_size;
1455 na_ptr->items[x]->data = xmalloc(value_size+1); 1570 na_ptr->items[x]->type = table_rec.ref_type;
1456 memcpy(na_ptr->items[x]->data, block_offset7.from, value_size); 1571 na_ptr->items[x]->data = xmalloc(value_size+1);
1457 na_ptr->items[x]->data[value_size] = '\0'; // it might be a string, null terminate it. 1572 memcpy(na_ptr->items[x]->data, block_offset7.from, value_size);
1458 } 1573 na_ptr->items[x]->data[value_size] = '\0'; // it might be a string, null terminate it.
1459 if (table_rec.ref_type == 0xd) { 1574 }
1460 // there is still more to do for the type of 0xD 1575 if (table_rec.ref_type == 0xd) {
1461 type_d_rec = (struct _type_d_rec*) na_ptr->items[x]->data; 1576 // there is still more to do for the type of 0xD embedded objects
1462 LE32_CPU(type_d_rec->id); 1577 type_d_rec = (struct _type_d_rec*) na_ptr->items[x]->data;
1463 na_ptr->items[x]->size = _pst_ff_getID2block(pf, type_d_rec->id, i2_head, &(na_ptr->items[x]->data)); 1578 LE32_CPU(type_d_rec->id);
1464 if (!na_ptr->items[x]->size){ 1579 na_ptr->items[x]->size = _pst_ff_getID2block(pf, type_d_rec->id, i2_head, &(na_ptr->items[x]->data));
1465 DEBUG_WARN(("not able to read the ID2 data. Setting to be read later. %#x\n", type_d_rec->id)); 1580 if (!na_ptr->items[x]->size){
1466 na_ptr->items[x]->type = type_d_rec->id; // fetch before freeing data, alias pointer 1581 DEBUG_WARN(("not able to read the ID2 data. Setting to be read later. %#x\n", type_d_rec->id));
1467 free(na_ptr->items[x]->data); 1582 na_ptr->items[x]->type = type_d_rec->id; // fetch before freeing data, alias pointer
1468 na_ptr->items[x]->data = NULL; 1583 free(na_ptr->items[x]->data);
1469 } 1584 na_ptr->items[x]->data = NULL;
1470 } 1585 }
1471 if (na_ptr->items[x]->type == 0) na_ptr->items[x]->type = table_rec.ref_type; 1586 }
1472 } else { 1587 if (table_rec.ref_type == 0x1f) {
1473 WARN(("ERROR Unknown ref_type %#x\n", table_rec.ref_type)); 1588 // there is more to do for the type 0x1f unicode strings
1474 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1589 VBUF_STATIC(strbuf, 1024);
1475 if (na_head) _pst_free_list(na_head); 1590 VBUF_STATIC(unibuf, 1024);
1476 DEBUG_RET(); 1591 //need UTF-16 zero-termination
1477 return NULL; 1592 vbset(strbuf, na_ptr->items[x]->data, na_ptr->items[x]->size);
1478 } 1593 vbappend(strbuf, "\0\0", 2);
1479 x++; 1594 DEBUG_INDEX(("Iconv in: "));
1480 } 1595 DEBUG_HEXDUMPC(strbuf->b, strbuf->dlen, 0x10);
1481 DEBUG_EMAIL(("increasing ind2_ptr by %i [%#x] bytes. Was %#x, Now %#x\n", rec_size, rec_size, ind2_ptr, ind2_ptr+rec_size)); 1596 vb_utf16to8(unibuf, strbuf->b, strbuf->dlen);
1482 ind2_ptr += rec_size; 1597 free(na_ptr->items[x]->data);
1483 } 1598 na_ptr->items[x]->size = unibuf->dlen;
1484 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); 1599 na_ptr->items[x]->data = xmalloc(unibuf->dlen);
1485 DEBUG_RET(); 1600 memcpy(na_ptr->items[x]->data, unibuf->b, unibuf->dlen);
1486 return na_head; 1601 DEBUG_INDEX(("Iconv out: "));
1602 DEBUG_HEXDUMPC(na_ptr->items[x]->data, na_ptr->items[x]->size, 0x10);
1603 }
1604 if (na_ptr->items[x]->type == 0) na_ptr->items[x]->type = table_rec.ref_type;
1605 } else {
1606 WARN(("ERROR Unknown ref_type %#x\n", table_rec.ref_type));
1607 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1608 if (na_head) _pst_free_list(na_head);
1609 DEBUG_RET();
1610 return NULL;
1611 }
1612 x++;
1613 }
1614 DEBUG_EMAIL(("increasing ind2_ptr by %i [%#x] bytes. Was %#x, Now %#x\n", rec_size, rec_size, ind2_ptr, ind2_ptr+rec_size));
1615 ind2_ptr += rec_size;
1616 }
1617 freeall(buf, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7);
1618 DEBUG_RET();
1619 return na_head;
1487 } 1620 }
1488 1621
1489 1622
1490 // check if item->email is NULL, and init if so 1623 // check if item->email is NULL, and init if so
1491 #define MALLOC_EMAIL(x) { if (!x->email) { x->email = (pst_item_email*) xmalloc(sizeof(pst_item_email)); memset(x->email, 0, sizeof(pst_item_email) );} } 1624 #define MALLOC_EMAIL(x) { if (!x->email) { x->email = (pst_item_email*) xmalloc(sizeof(pst_item_email)); memset(x->email, 0, sizeof(pst_item_email) );} }
1492 #define MALLOC_FOLDER(x) { if (!x->folder) { x->folder = (pst_item_folder*) xmalloc(sizeof(pst_item_folder)); memset(x->folder, 0, sizeof(pst_item_folder) );} } 1625 #define MALLOC_FOLDER(x) { if (!x->folder) { x->folder = (pst_item_folder*) xmalloc(sizeof(pst_item_folder)); memset(x->folder, 0, sizeof(pst_item_folder) );} }
1493 #define MALLOC_CONTACT(x) { if (!x->contact) { x->contact = (pst_item_contact*) xmalloc(sizeof(pst_item_contact)); memset(x->contact, 0, sizeof(pst_item_contact) );} } 1626 #define MALLOC_CONTACT(x) { if (!x->contact) { x->contact = (pst_item_contact*) xmalloc(sizeof(pst_item_contact)); memset(x->contact, 0, sizeof(pst_item_contact) );} }
1494 #define MALLOC_MESSAGESTORE(x) { if (!x->message_store) { x->message_store = (pst_item_message_store*) xmalloc(sizeof(pst_item_message_store)); memset(x->message_store, 0, sizeof(pst_item_message_store));} } 1627 #define MALLOC_MESSAGESTORE(x) { if (!x->message_store) { x->message_store = (pst_item_message_store*) xmalloc(sizeof(pst_item_message_store)); memset(x->message_store, 0, sizeof(pst_item_message_store));} }
1495 #define MALLOC_JOURNAL(x) { if (!x->journal) { x->journal = (pst_item_journal*) xmalloc(sizeof(pst_item_journal)); memset(x->journal, 0, sizeof(pst_item_journal) );} } 1628 #define MALLOC_JOURNAL(x) { if (!x->journal) { x->journal = (pst_item_journal*) xmalloc(sizeof(pst_item_journal)); memset(x->journal, 0, sizeof(pst_item_journal) );} }
1496 #define MALLOC_APPOINTMENT(x) { if (!x->appointment) { x->appointment = (pst_item_appointment*) xmalloc(sizeof(pst_item_appointment)); memset(x->appointment, 0, sizeof(pst_item_appointment) );} } 1629 #define MALLOC_APPOINTMENT(x) { if (!x->appointment) { x->appointment = (pst_item_appointment*) xmalloc(sizeof(pst_item_appointment)); memset(x->appointment, 0, sizeof(pst_item_appointment) );} }
1497 // malloc space and copy the current item's data null terminated 1630 // malloc space and copy the current item's data null terminated
1498 #define LIST_COPY(targ, type) { \ 1631 #define LIST_COPY(targ, type) { \
1499 targ = type realloc(targ, list->items[x]->size+1); \ 1632 targ = type realloc(targ, list->items[x]->size+1); \
1500 memcpy(targ, list->items[x]->data, list->items[x]->size); \ 1633 memcpy(targ, list->items[x]->data, list->items[x]->size); \
1501 memset(((char*)targ)+list->items[x]->size, 0, 1); \ 1634 memset(((char*)targ)+list->items[x]->size, 0, 1); \
1502 } 1635 }
1503 // malloc space and copy the current item's data and size 1636 // malloc space and copy the current item's data and size
1504 #define LIST_COPY_SIZE(targ, type, mysize) { \ 1637 #define LIST_COPY_SIZE(targ, type, mysize) { \
1505 mysize = list->items[x]->size; \ 1638 mysize = list->items[x]->size; \
1506 targ = type realloc(targ, mysize); \ 1639 targ = type realloc(targ, mysize); \
1507 memcpy(targ, list->items[x]->data, mysize); \ 1640 memcpy(targ, list->items[x]->data, mysize); \
1508 } 1641 }
1509 1642
1510 #define NULL_CHECK(x) { if (!x) { DEBUG_EMAIL(("NULL_CHECK: Null Found\n")); break;} } 1643 #define NULL_CHECK(x) { if (!x) { DEBUG_EMAIL(("NULL_CHECK: Null Found\n")); break;} }
1511 1644
1512 #define MOVE_NEXT(targ) { \ 1645 #define MOVE_NEXT(targ) { \
1513 if (next){\ 1646 if (next){\
1514 if (!targ) {\ 1647 if (!targ) {\
1515 DEBUG_EMAIL(("MOVE_NEXT: Target is NULL. Will stop processing this option\n"));\ 1648 DEBUG_EMAIL(("MOVE_NEXT: Target is NULL. Will stop processing this option\n"));\
1516 break;\ 1649 break;\
1517 }\ 1650 }\
1518 targ = targ->next;\ 1651 targ = targ->next;\
1519 if (!targ) {\ 1652 if (!targ) {\
1520 DEBUG_EMAIL(("MOVE_NEXT: Target is NULL after next. Will stop processing this option\n"));\ 1653 DEBUG_EMAIL(("MOVE_NEXT: Target is NULL after next. Will stop processing this option\n"));\
1521 break;\ 1654 break;\
1522 }\ 1655 }\
1523 next=0;\ 1656 next=0;\
1524 }\ 1657 }\
1525 } 1658 }
1526 1659
1527 1660
1528 int32_t _pst_process(pst_num_array *list , pst_item *item, pst_item_attach *attach) { 1661 int32_t _pst_process(pst_num_array *list , pst_item *item, pst_item_attach *attach) {
1529 int32_t x, t; 1662 int32_t x, t;
1530 int32_t next = 0; 1663 int32_t next = 0;
1531 pst_item_extra_field *ef; 1664 pst_item_extra_field *ef;
1532 1665
1533 DEBUG_ENT("_pst_process"); 1666 DEBUG_ENT("_pst_process");
1534 if (!item) { 1667 if (!item) {
1535 DEBUG_EMAIL(("item cannot be NULL.\n")); 1668 DEBUG_EMAIL(("item cannot be NULL.\n"));
1536 DEBUG_RET(); 1669 DEBUG_RET();
1537 return -1; 1670 return -1;
1538 } 1671 }
1539 1672
1540 while (list) { 1673 while (list) {
1541 x = 0; 1674 x = 0;
1542 while (x < list->count_item) { 1675 while (x < list->count_item) {
1543 // check here to see if the id is one that is mapped. 1676 // check here to see if the id is one that is mapped.
1544 DEBUG_EMAIL(("#%d - id: %#x type: %#x length: %#x\n", x, list->items[x]->id, list->items[x]->type, list->items[x]->size)); 1677 DEBUG_EMAIL(("#%d - id: %#x type: %#x length: %#x\n", x, list->items[x]->id, list->items[x]->type, list->items[x]->size));
1545 1678
1546 switch (list->items[x]->id) { 1679 switch (list->items[x]->id) {
1547 case PST_ATTRIB_HEADER: // CUSTOM attribute for saying the Extra Headers 1680 case PST_ATTRIB_HEADER: // CUSTOM attribute for saying the Extra Headers
1548 DEBUG_EMAIL(("Extra Field - ")); 1681 DEBUG_EMAIL(("Extra Field - "));
1549 ef = (pst_item_extra_field*) xmalloc(sizeof(pst_item_extra_field)); 1682 ef = (pst_item_extra_field*) xmalloc(sizeof(pst_item_extra_field));
1550 memset(ef, 0, sizeof(pst_item_extra_field)); 1683 memset(ef, 0, sizeof(pst_item_extra_field));
1551 ef->field_name = (char*) xmalloc(strlen(list->items[x]->extra)+1); 1684 ef->field_name = (char*) xmalloc(strlen(list->items[x]->extra)+1);
1552 strcpy(ef->field_name, list->items[x]->extra); 1685 strcpy(ef->field_name, list->items[x]->extra);
1553 LIST_COPY(ef->value, (char*)); 1686 LIST_COPY(ef->value, (char*));
1554 ef->next = item->extra_fields; 1687 ef->next = item->extra_fields;
1555 item->extra_fields = ef; 1688 item->extra_fields = ef;
1556 DEBUG_EMAIL(("\"%s\" = \"%s\"\n", ef->field_name, ef->value)); 1689 DEBUG_EMAIL(("\"%s\" = \"%s\"\n", ef->field_name, ef->value));
1557 break; 1690 break;
1558 case 0x0002: // PR_ALTERNATE_RECIPIENT_ALLOWED 1691 case 0x0002: // PR_ALTERNATE_RECIPIENT_ALLOWED
1559 // If set to true, the sender allows this email to be autoforwarded 1692 // If set to true, the sender allows this email to be autoforwarded
1560 DEBUG_EMAIL(("AutoForward allowed - ")); 1693 DEBUG_EMAIL(("AutoForward allowed - "));
1561 MALLOC_EMAIL(item); 1694 MALLOC_EMAIL(item);
1562 if (*((short int*)list->items[x]->data) != 0) { 1695 if (*((short int*)list->items[x]->data) != 0) {
1563 DEBUG_EMAIL(("True\n")); 1696 DEBUG_EMAIL(("True\n"));
1564 item->email->autoforward = 1; 1697 item->email->autoforward = 1;
1565 } else { 1698 } else {
1566 DEBUG_EMAIL(("False\n")); 1699 DEBUG_EMAIL(("False\n"));
1567 item->email->autoforward = -1; 1700 item->email->autoforward = -1;
1568 } 1701 }
1569 break; 1702 break;
1570 case 0x0003: // Extended Attributes table 1703 case 0x0003: // Extended Attributes table
1571 DEBUG_EMAIL(("Extended Attributes Table - NOT PROCESSED\n")); 1704 DEBUG_EMAIL(("Extended Attributes Table - NOT PROCESSED\n"));
1572 break; 1705 break;
1573 case 0x0017: // PR_IMPORTANCE 1706 case 0x0017: // PR_IMPORTANCE
1574 // How important the sender deems it to be 1707 // How important the sender deems it to be
1575 // 0 - Low 1708 // 0 - Low
1576 // 1 - Normal 1709 // 1 - Normal
1577 // 2 - High 1710 // 2 - High
1578 1711
1579 DEBUG_EMAIL(("Importance Level - ")); 1712 DEBUG_EMAIL(("Importance Level - "));
1580 MALLOC_EMAIL(item); 1713 MALLOC_EMAIL(item);
1581 memcpy(&(item->email->importance), list->items[x]->data, sizeof(item->email->importance)); 1714 memcpy(&(item->email->importance), list->items[x]->data, sizeof(item->email->importance));
1582 LE32_CPU(item->email->importance); 1715 LE32_CPU(item->email->importance);
1583 t = item->email->importance; 1716 t = item->email->importance;
1584 DEBUG_EMAIL(("%s [%i]\n", (t==0?"Low":(t==1?"Normal":"High")), t)); 1717 DEBUG_EMAIL(("%s [%i]\n", (t==0?"Low":(t==1?"Normal":"High")), t));
1585 break; 1718 break;
1586 case 0x001A: // PR_MESSAGE_CLASS Ascii type of messages - NOT FOLDERS 1719 case 0x001A: // PR_MESSAGE_CLASS Ascii type of messages - NOT FOLDERS
1587 // must be case insensitive 1720 // must be case insensitive
1588 DEBUG_EMAIL(("IPM.x - ")); 1721 DEBUG_EMAIL(("IPM.x - "));
1589 LIST_COPY(item->ascii_type, (char*)); 1722 LIST_COPY(item->ascii_type, (char*));
1590 if (pst_strincmp("IPM.Note", item->ascii_type, 8) == 0) 1723 if (pst_strincmp("IPM.Note", item->ascii_type, 8) == 0)
1591 // the string begins with IPM.Note... 1724 // the string begins with IPM.Note...
1592 item->type = PST_TYPE_NOTE; 1725 item->type = PST_TYPE_NOTE;
1593 else if (pst_stricmp("IPM", item->ascii_type) == 0) 1726 else if (pst_stricmp("IPM", item->ascii_type) == 0)
1594 // the whole string is just IPM 1727 // the whole string is just IPM
1595 item->type = PST_TYPE_NOTE; 1728 item->type = PST_TYPE_NOTE;
1596 else if (pst_strincmp("IPM.Contact", item->ascii_type, 11) == 0) 1729 else if (pst_strincmp("IPM.Contact", item->ascii_type, 11) == 0)
1597 // the string begins with IPM.Contact... 1730 // the string begins with IPM.Contact...
1598 item->type = PST_TYPE_CONTACT; 1731 item->type = PST_TYPE_CONTACT;
1599 else if (pst_strincmp("REPORT.IPM.Note", item->ascii_type, 15) == 0) 1732 else if (pst_strincmp("REPORT.IPM.Note", item->ascii_type, 15) == 0)
1600 // the string begins with the above 1733 // the string begins with the above
1601 item->type = PST_TYPE_REPORT; 1734 item->type = PST_TYPE_REPORT;
1602 else if (pst_strincmp("IPM.Activity", item->ascii_type, 12) == 0) 1735 else if (pst_strincmp("IPM.Activity", item->ascii_type, 12) == 0)
1603 item->type = PST_TYPE_JOURNAL; 1736 item->type = PST_TYPE_JOURNAL;
1604 else if (pst_strincmp("IPM.Appointment", item->ascii_type, 15) == 0) 1737 else if (pst_strincmp("IPM.Appointment", item->ascii_type, 15) == 0)
1605 item->type = PST_TYPE_APPOINTMENT; 1738 item->type = PST_TYPE_APPOINTMENT;
1606 else 1739 else
1607 item->type = PST_TYPE_OTHER; 1740 item->type = PST_TYPE_OTHER;
1608 1741
1609 DEBUG_EMAIL(("%s\n", item->ascii_type)); 1742 DEBUG_EMAIL(("%s\n", item->ascii_type));
1610 break; 1743 break;
1611 case 0x0023: // PR_ORIGINATOR_DELIVERY_REPORT_REQUESTED 1744 case 0x0023: // PR_ORIGINATOR_DELIVERY_REPORT_REQUESTED
1612 // set if the sender wants a delivery report from all recipients 1745 // set if the sender wants a delivery report from all recipients
1613 DEBUG_EMAIL(("Global Delivery Report - ")); 1746 DEBUG_EMAIL(("Global Delivery Report - "));
1614 MALLOC_EMAIL(item); 1747 MALLOC_EMAIL(item);
1615 if (*(int16_t*)list->items[x]->data != 0) { 1748 if (*(int16_t*)list->items[x]->data != 0) {
1616 DEBUG_EMAIL(("True\n")); 1749 DEBUG_EMAIL(("True\n"));
1617 item->email->delivery_report = 1; 1750 item->email->delivery_report = 1;
1618 } else { 1751 } else {
1619 DEBUG_EMAIL(("False\n")); 1752 DEBUG_EMAIL(("False\n"));
1620 item->email->delivery_report = 0; 1753 item->email->delivery_report = 0;
1621 } 1754 }
1622 break; 1755 break;
1623 case 0x0026: // PR_PRIORITY 1756 case 0x0026: // PR_PRIORITY
1624 // Priority of a message 1757 // Priority of a message
1625 // -1 NonUrgent 1758 // -1 NonUrgent
1626 // 0 Normal 1759 // 0 Normal
1627 // 1 Urgent 1760 // 1 Urgent
1628 DEBUG_EMAIL(("Priority - ")); 1761 DEBUG_EMAIL(("Priority - "));
1629 MALLOC_EMAIL(item); 1762 MALLOC_EMAIL(item);
1630 memcpy(&(item->email->priority), list->items[x]->data, sizeof(item->email->priority)); 1763 memcpy(&(item->email->priority), list->items[x]->data, sizeof(item->email->priority));
1631 LE32_CPU(item->email->priority); 1764 LE32_CPU(item->email->priority);
1632 t = item->email->priority; 1765 t = item->email->priority;
1633 DEBUG_EMAIL(("%s [%i]\n", (t<0?"NonUrgent":(t==0?"Normal":"Urgent")), t)); 1766 DEBUG_EMAIL(("%s [%i]\n", (t<0?"NonUrgent":(t==0?"Normal":"Urgent")), t));
1634 break; 1767 break;
1635 case 0x0029:// PR_READ_RECEIPT_REQUESTED 1768 case 0x0029:// PR_READ_RECEIPT_REQUESTED
1636 DEBUG_EMAIL(("Read Receipt - ")); 1769 DEBUG_EMAIL(("Read Receipt - "));
1637 MALLOC_EMAIL(item); 1770 MALLOC_EMAIL(item);
1638 if (*(short int*)list->items[x]->data != 0) { 1771 if (*(short int*)list->items[x]->data != 0) {
1639 DEBUG_EMAIL(("True\n")); 1772 DEBUG_EMAIL(("True\n"));
1640 item->email->read_receipt = 1; 1773 item->email->read_receipt = 1;
1641 } else { 1774 } else {
1642 DEBUG_EMAIL(("False\n")); 1775 DEBUG_EMAIL(("False\n"));
1643 item->email->read_receipt = 0; 1776 item->email->read_receipt = 0;
1644 } 1777 }
1645 break; 1778 break;
1646 case 0x002B: // PR_RECIPIENT_REASSIGNMENT_PROHIBITED 1779 case 0x002B: // PR_RECIPIENT_REASSIGNMENT_PROHIBITED
1647 DEBUG_EMAIL(("Reassignment Prohibited (Private) - ")); 1780 DEBUG_EMAIL(("Reassignment Prohibited (Private) - "));
1648 if (*(short int*)list->items[x]->data != 0) { 1781 if (*(short int*)list->items[x]->data != 0) {
1649 DEBUG_EMAIL(("True\n")); 1782 DEBUG_EMAIL(("True\n"));
1650 item->private_member = 1; 1783 item->private_member = 1;
1651 } else { 1784 } else {
1652 DEBUG_EMAIL(("False\n")); 1785 DEBUG_EMAIL(("False\n"));
1653 item->private_member = 0; 1786 item->private_member = 0;
1654 } 1787 }
1655 break; 1788 break;
1656 case 0x002E: // PR_ORIGINAL_SENSITIVITY 1789 case 0x002E: // PR_ORIGINAL_SENSITIVITY
1657 // the sensitivity of the message before being replied to or forwarded 1790 // the sensitivity of the message before being replied to or forwarded
1658 // 0 - None 1791 // 0 - None
1659 // 1 - Personal 1792 // 1 - Personal
1660 // 2 - Private 1793 // 2 - Private
1661 // 3 - Company Confidential 1794 // 3 - Company Confidential
1662 DEBUG_EMAIL(("Original Sensitivity - ")); 1795 DEBUG_EMAIL(("Original Sensitivity - "));
1663 MALLOC_EMAIL(item); 1796 MALLOC_EMAIL(item);
1664 memcpy(&(item->email->orig_sensitivity), list->items[x]->data, sizeof(item->email->orig_sensitivity)); 1797 memcpy(&(item->email->orig_sensitivity), list->items[x]->data, sizeof(item->email->orig_sensitivity));
1665 LE32_CPU(item->email->orig_sensitivity); 1798 LE32_CPU(item->email->orig_sensitivity);
1666 t = item->email->orig_sensitivity; 1799 t = item->email->orig_sensitivity;
1667 DEBUG_EMAIL(("%s [%i]\n", (t==0?"None":(t==1?"Personal": 1800 DEBUG_EMAIL(("%s [%i]\n", (t==0?"None":(t==1?"Personal":
1668 (t==2?"Private":"Company Confidential"))), t)); 1801 (t==2?"Private":"Company Confidential"))), t));
1669 break; 1802 break;
1670 case 0x0036: // PR_SENSITIVITY 1803 case 0x0036: // PR_SENSITIVITY
1671 // sender's opinion of the sensitivity of an email 1804 // sender's opinion of the sensitivity of an email
1672 // 0 - None 1805 // 0 - None
1673 // 1 - Personal 1806 // 1 - Personal
1674 // 2 - Private 1807 // 2 - Private
1675 // 3 - Company Confidiential 1808 // 3 - Company Confidiential
1676 DEBUG_EMAIL(("Sensitivity - ")); 1809 DEBUG_EMAIL(("Sensitivity - "));
1677 MALLOC_EMAIL(item); 1810 MALLOC_EMAIL(item);
1678 memcpy(&(item->email->sensitivity), list->items[x]->data, sizeof(item->email->sensitivity)); 1811 memcpy(&(item->email->sensitivity), list->items[x]->data, sizeof(item->email->sensitivity));
1679 LE32_CPU(item->email->sensitivity); 1812 LE32_CPU(item->email->sensitivity);
1680 t = item->email->sensitivity; 1813 t = item->email->sensitivity;
1681 DEBUG_EMAIL(("%s [%i]\n", (t==0?"None":(t==1?"Personal": 1814 DEBUG_EMAIL(("%s [%i]\n", (t==0?"None":(t==1?"Personal":
1682 (t==2?"Private":"Company Confidential"))), t)); 1815 (t==2?"Private":"Company Confidential"))), t));
1683 break; 1816 break;
1684 case 0x0037: // PR_SUBJECT raw subject 1817 case 0x0037: // PR_SUBJECT raw subject
1685 // if (list->items[x]->id == 0x0037) { 1818 // if (list->items[x]->id == 0x0037) {
1686 DEBUG_EMAIL(("Raw Subject - ")); 1819 DEBUG_EMAIL(("Raw Subject - "));
1687 MALLOC_EMAIL(item); 1820 MALLOC_EMAIL(item);
1688 item->email->subject = (pst_item_email_subject*) realloc(item->email->subject, sizeof(pst_item_email_subject)); 1821 item->email->subject = (pst_item_email_subject*) realloc(item->email->subject, sizeof(pst_item_email_subject));
1689 memset(item->email->subject, 0, sizeof(pst_item_email_subject)); 1822 memset(item->email->subject, 0, sizeof(pst_item_email_subject));
1690 DEBUG_EMAIL((" [size = %i] ", list->items[x]->size)); 1823 DEBUG_EMAIL((" [size = %i] ", list->items[x]->size));
1691 if (list->items[x]->size > 0) { 1824 if (list->items[x]->size > 0) {
1692 if (isprint(list->items[x]->data[0])) { 1825 if (isprint(list->items[x]->data[0])) {
1693 // then there are no control bytes at the front 1826 // then there are no control bytes at the front
1694 item->email->subject->off1 = 0; 1827 item->email->subject->off1 = 0;
1695 item->email->subject->off2 = 0; 1828 item->email->subject->off2 = 0;
1696 item->email->subject->subj = realloc(item->email->subject->subj, list->items[x]->size+1); 1829 item->email->subject->subj = realloc(item->email->subject->subj, list->items[x]->size+1);
1697 memset(item->email->subject->subj, 0, list->items[x]->size+1); 1830 memset(item->email->subject->subj, 0, list->items[x]->size+1);
1698 memcpy(item->email->subject->subj, list->items[x]->data, list->items[x]->size); 1831 memcpy(item->email->subject->subj, list->items[x]->data, list->items[x]->size);
1699 } else { 1832 } else {
1700 DEBUG_EMAIL(("Raw Subject has control codes\n")); 1833 DEBUG_EMAIL(("Raw Subject has control codes\n"));
1701 // there might be some control bytes in the first and second bytes 1834 // there might be some control bytes in the first and second bytes
1702 item->email->subject->off1 = list->items[x]->data[0]; 1835 item->email->subject->off1 = list->items[x]->data[0];
1703 item->email->subject->off2 = list->items[x]->data[1]; 1836 item->email->subject->off2 = list->items[x]->data[1];
1704 item->email->subject->subj = realloc(item->email->subject->subj, (list->items[x]->size-2)+1); 1837 item->email->subject->subj = realloc(item->email->subject->subj, (list->items[x]->size-2)+1);
1705 memset(item->email->subject->subj, 0, list->items[x]->size-1); 1838 memset(item->email->subject->subj, 0, list->items[x]->size-1);
1706 memcpy(item->email->subject->subj, &(list->items[x]->data[2]), list->items[x]->size-2); 1839 memcpy(item->email->subject->subj, &(list->items[x]->data[2]), list->items[x]->size-2);
1707 } 1840 }
1708 DEBUG_EMAIL(("%s\n", item->email->subject->subj)); 1841 DEBUG_EMAIL(("%s\n", item->email->subject->subj));
1709 } else { 1842 } else {
1710 // obviously outlook has decided not to be straight with this one. 1843 // obviously outlook has decided not to be straight with this one.
1711 item->email->subject->off1 = 0; 1844 item->email->subject->off1 = 0;
1712 item->email->subject->off2 = 0; 1845 item->email->subject->off2 = 0;
1713 item->email->subject = NULL; 1846 item->email->subject = NULL;
1714 DEBUG_EMAIL(("NULL subject detected\n")); 1847 DEBUG_EMAIL(("NULL subject detected\n"));
1715 } 1848 }
1716 break; 1849 break;
1717 case 0x0039: // PR_CLIENT_SUBMIT_TIME Date Email Sent/Created 1850 case 0x0039: // PR_CLIENT_SUBMIT_TIME Date Email Sent/Created
1718 DEBUG_EMAIL(("Date sent - ")); 1851 DEBUG_EMAIL(("Date sent - "));
1719 MALLOC_EMAIL(item); 1852 MALLOC_EMAIL(item);
1720 LIST_COPY(item->email->sent_date, (FILETIME*)); 1853 LIST_COPY(item->email->sent_date, (FILETIME*));
1721 LE32_CPU(item->email->sent_date->dwLowDateTime); 1854 LE32_CPU(item->email->sent_date->dwLowDateTime);
1722 LE32_CPU(item->email->sent_date->dwHighDateTime); 1855 LE32_CPU(item->email->sent_date->dwHighDateTime);
1723 DEBUG_EMAIL(("%s", fileTimeToAscii(item->email->sent_date))); 1856 DEBUG_EMAIL(("%s", fileTimeToAscii(item->email->sent_date)));
1724 break; 1857 break;
1725 case 0x003B: // PR_SENT_REPRESENTING_SEARCH_KEY Sender address 1 1858 case 0x003B: // PR_SENT_REPRESENTING_SEARCH_KEY Sender address 1
1726 DEBUG_EMAIL(("Sent on behalf of address 1 - ")); 1859 DEBUG_EMAIL(("Sent on behalf of address 1 - "));
1727 MALLOC_EMAIL(item); 1860 MALLOC_EMAIL(item);
1728 LIST_COPY(item->email->outlook_sender, (char*)); 1861 LIST_COPY(item->email->outlook_sender, (char*));
1729 DEBUG_EMAIL(("%s\n", item->email->outlook_sender)); 1862 DEBUG_EMAIL(("%s\n", item->email->outlook_sender));
1730 break; 1863 break;
1731 case 0x003F: // PR_RECEIVED_BY_ENTRYID Structure containing Recipient 1864 case 0x003F: // PR_RECEIVED_BY_ENTRYID Structure containing Recipient
1732 DEBUG_EMAIL(("Recipient Structure 1 -- NOT HANDLED\n")); 1865 DEBUG_EMAIL(("Recipient Structure 1 -- NOT HANDLED\n"));
1733 break; 1866 break;
1734 case 0x0040: // PR_RECEIVED_BY_NAME Name of Recipient Structure 1867 case 0x0040: // PR_RECEIVED_BY_NAME Name of Recipient Structure
1735 DEBUG_EMAIL(("Received By Name 1 -- NOT HANDLED\n")); 1868 DEBUG_EMAIL(("Received By Name 1 -- NOT HANDLED\n"));
1736 break; 1869 break;
1737 case 0x0041: // PR_SENT_REPRESENTING_ENTRYID Structure containing Sender 1870 case 0x0041: // PR_SENT_REPRESENTING_ENTRYID Structure containing Sender
1738 DEBUG_EMAIL(("Sent on behalf of Structure 1 -- NOT HANDLED\n")); 1871 DEBUG_EMAIL(("Sent on behalf of Structure 1 -- NOT HANDLED\n"));
1739 break; 1872 break;
1740 case 0x0042: // PR_SENT_REPRESENTING_NAME Name of Sender Structure 1873 case 0x0042: // PR_SENT_REPRESENTING_NAME Name of Sender Structure
1741 DEBUG_EMAIL(("Sent on behalf of Structure Name - ")); 1874 DEBUG_EMAIL(("Sent on behalf of Structure Name - "));
1742 MALLOC_EMAIL(item); 1875 MALLOC_EMAIL(item);
1743 LIST_COPY(item->email->outlook_sender_name, (char*)); 1876 LIST_COPY(item->email->outlook_sender_name, (char*));
1744 DEBUG_EMAIL(("%s\n", item->email->outlook_sender_name)); 1877 DEBUG_EMAIL(("%s\n", item->email->outlook_sender_name));
1745 break; 1878 break;
1746 case 0x0043: // PR_RCVD_REPRESENTING_ENTRYID Recipient Structure 2 1879 case 0x0043: // PR_RCVD_REPRESENTING_ENTRYID Recipient Structure 2
1747 DEBUG_EMAIL(("Received on behalf of Structure -- NOT HANDLED\n")); 1880 DEBUG_EMAIL(("Received on behalf of Structure -- NOT HANDLED\n"));
1748 break; 1881 break;
1749 case 0x0044: // PR_RCVD_REPRESENTING_NAME Name of Recipient Structure 2 1882 case 0x0044: // PR_RCVD_REPRESENTING_NAME Name of Recipient Structure 2
1750 DEBUG_EMAIL(("Received on behalf of Structure Name -- NOT HANDLED\n")); 1883 DEBUG_EMAIL(("Received on behalf of Structure Name -- NOT HANDLED\n"));
1751 break; 1884 break;
1752 case 0x004F: // PR_REPLY_RECIPIENT_ENTRIES Reply-To Structure 1885 case 0x004F: // PR_REPLY_RECIPIENT_ENTRIES Reply-To Structure
1753 DEBUG_EMAIL(("Reply-To Structure -- NOT HANDLED\n")); 1886 DEBUG_EMAIL(("Reply-To Structure -- NOT HANDLED\n"));
1754 break; 1887 break;
1755 case 0x0050: // PR_REPLY_RECIPIENT_NAMES Name of Reply-To Structure 1888 case 0x0050: // PR_REPLY_RECIPIENT_NAMES Name of Reply-To Structure
1756 DEBUG_EMAIL(("Name of Reply-To Structure -")); 1889 DEBUG_EMAIL(("Name of Reply-To Structure -"));
1757 MALLOC_EMAIL(item); 1890 MALLOC_EMAIL(item);
1758 LIST_COPY(item->email->reply_to, (char*)); 1891 LIST_COPY(item->email->reply_to, (char*));
1759 DEBUG_EMAIL(("%s\n", item->email->reply_to)); 1892 DEBUG_EMAIL(("%s\n", item->email->reply_to));
1760 break; 1893 break;
1761 case 0x0051: // PR_RECEIVED_BY_SEARCH_KEY Recipient Address 1 1894 case 0x0051: // PR_RECEIVED_BY_SEARCH_KEY Recipient Address 1
1762 DEBUG_EMAIL(("Recipient's Address 1 (Search Key) - ")); 1895 DEBUG_EMAIL(("Recipient's Address 1 (Search Key) - "));
1763 MALLOC_EMAIL(item); 1896 MALLOC_EMAIL(item);
1764 LIST_COPY (item->email->outlook_recipient, (char*)); 1897 LIST_COPY (item->email->outlook_recipient, (char*));
1765 DEBUG_EMAIL(("%s\n", item->email->outlook_recipient)); 1898 DEBUG_EMAIL(("%s\n", item->email->outlook_recipient));
1766 break; 1899 break;
1767 case 0x0052: // PR_RCVD_REPRESENTING_SEARCH_KEY Recipient Address 2 1900 case 0x0052: // PR_RCVD_REPRESENTING_SEARCH_KEY Recipient Address 2
1768 DEBUG_EMAIL(("Received on behalf of Address (Search Key) - ")); 1901 DEBUG_EMAIL(("Received on behalf of Address (Search Key) - "));
1769 MALLOC_EMAIL(item); 1902 MALLOC_EMAIL(item);
1770 LIST_COPY(item->email->outlook_recipient2, (char*)); 1903 LIST_COPY(item->email->outlook_recipient2, (char*));
1771 DEBUG_EMAIL(("%s\n", item->email->outlook_recipient2)); 1904 DEBUG_EMAIL(("%s\n", item->email->outlook_recipient2));
1772 break; 1905 break;
1773 case 0x0057: // PR_MESSAGE_TO_ME 1906 case 0x0057: // PR_MESSAGE_TO_ME
1774 // this user is listed explicitly in the TO address 1907 // this user is listed explicitly in the TO address
1775 DEBUG_EMAIL(("My address in TO field - ")); 1908 DEBUG_EMAIL(("My address in TO field - "));
1776 MALLOC_EMAIL(item); 1909 MALLOC_EMAIL(item);
1777 if (*(int16_t*)list->items[x]->data != 0) { 1910 if (*(int16_t*)list->items[x]->data != 0) {
1778 DEBUG_EMAIL(("True\n")); 1911 DEBUG_EMAIL(("True\n"));
1779 item->email->message_to_me = 1; 1912 item->email->message_to_me = 1;
1780 } else { 1913 } else {
1781 DEBUG_EMAIL(("False\n")); 1914 DEBUG_EMAIL(("False\n"));
1782 item->email->message_to_me = 0; 1915 item->email->message_to_me = 0;
1783 } 1916 }
1784 break; 1917 break;
1785 case 0x0058: // PR_MESSAGE_CC_ME 1918 case 0x0058: // PR_MESSAGE_CC_ME
1786 // this user is listed explicitly in the CC address 1919 // this user is listed explicitly in the CC address
1787 DEBUG_EMAIL(("My address in CC field - ")); 1920 DEBUG_EMAIL(("My address in CC field - "));
1788 MALLOC_EMAIL(item); 1921 MALLOC_EMAIL(item);
1789 if (*(int16_t*)list->items[x]->data != 0) { 1922 if (*(int16_t*)list->items[x]->data != 0) {
1790 DEBUG_EMAIL(("True\n")); 1923 DEBUG_EMAIL(("True\n"));
1791 item->email->message_cc_me = 1; 1924 item->email->message_cc_me = 1;
1792 } else { 1925 } else {
1793 DEBUG_EMAIL(("False\n")); 1926 DEBUG_EMAIL(("False\n"));
1794 item->email->message_cc_me = 0; 1927 item->email->message_cc_me = 0;
1795 } 1928 }
1796 break; 1929 break;
1797 case 0x0059: //PR_MESSAGE_RECIP_ME 1930 case 0x0059: //PR_MESSAGE_RECIP_ME
1798 // this user appears in TO, CC or BCC address list 1931 // this user appears in TO, CC or BCC address list
1799 DEBUG_EMAIL(("Message addressed to me - ")); 1932 DEBUG_EMAIL(("Message addressed to me - "));
1800 MALLOC_EMAIL(item); 1933 MALLOC_EMAIL(item);
1801 if (*(int16_t*)list->items[x]->data != 0) { 1934 if (*(int16_t*)list->items[x]->data != 0) {
1802 DEBUG_EMAIL(("True\n")); 1935 DEBUG_EMAIL(("True\n"));
1803 item->email->message_recip_me = 1; 1936 item->email->message_recip_me = 1;
1804 } else { 1937 } else {
1805 DEBUG_EMAIL(("False\n")); 1938 DEBUG_EMAIL(("False\n"));
1806 item->email->message_recip_me = 0; 1939 item->email->message_recip_me = 0;
1807 } 1940 }
1808 break; 1941 break;
1809 case 0x0063: // PR_RESPONSE_REQUESTED 1942 case 0x0063: // PR_RESPONSE_REQUESTED
1810 DEBUG_EMAIL(("Response requested - ")); 1943 DEBUG_EMAIL(("Response requested - "));
1811 if (*(int16_t*)list->items[x]->data != 0) { 1944 if (*(int16_t*)list->items[x]->data != 0) {
1812 DEBUG_EMAIL(("True\n")); 1945 DEBUG_EMAIL(("True\n"));
1813 item->response_requested = 1; 1946 item->response_requested = 1;
1814 } else { 1947 } else {
1815 DEBUG_EMAIL(("False\n")); 1948 DEBUG_EMAIL(("False\n"));
1816 item->response_requested = 0; 1949 item->response_requested = 0;
1817 } 1950 }
1818 break; 1951 break;
1819 case 0x0064: // PR_SENT_REPRESENTING_ADDRTYPE Access method for Sender Address 1952 case 0x0064: // PR_SENT_REPRESENTING_ADDRTYPE Access method for Sender Address
1820 DEBUG_EMAIL(("Sent on behalf of address type - ")); 1953 DEBUG_EMAIL(("Sent on behalf of address type - "));
1821 MALLOC_EMAIL(item); 1954 MALLOC_EMAIL(item);
1822 LIST_COPY(item->email->sender_access, (char*)); 1955 LIST_COPY(item->email->sender_access, (char*));
1823 DEBUG_EMAIL(("%s\n", item->email->sender_access)); 1956 DEBUG_EMAIL(("%s\n", item->email->sender_access));
1824 break; 1957 break;
1825 case 0x0065: // PR_SENT_REPRESENTING_EMAIL_ADDRESS Sender Address 1958 case 0x0065: // PR_SENT_REPRESENTING_EMAIL_ADDRESS Sender Address
1826 DEBUG_EMAIL(("Sent on behalf of Address - ")); 1959 DEBUG_EMAIL(("Sent on behalf of Address - "));
1827 MALLOC_EMAIL(item); 1960 MALLOC_EMAIL(item);
1828 LIST_COPY(item->email->sender_address, (char*)); 1961 LIST_COPY(item->email->sender_address, (char*));
1829 DEBUG_EMAIL(("%s\n", item->email->sender_address)); 1962 DEBUG_EMAIL(("%s\n", item->email->sender_address));
1830 break; 1963 break;
1831 case 0x0070: // PR_CONVERSATION_TOPIC Processed Subject 1964 case 0x0070: // PR_CONVERSATION_TOPIC Processed Subject
1832 DEBUG_EMAIL(("Processed Subject (Conversation Topic) - ")); 1965 DEBUG_EMAIL(("Processed Subject (Conversation Topic) - "));
1833 MALLOC_EMAIL(item); 1966 MALLOC_EMAIL(item);
1834 LIST_COPY(item->email->proc_subject, (char*)); 1967 LIST_COPY(item->email->proc_subject, (char*));
1835 DEBUG_EMAIL(("%s\n", item->email->proc_subject)); 1968 DEBUG_EMAIL(("%s\n", item->email->proc_subject));
1836 break; 1969 break;
1837 case 0x0071: // PR_CONVERSATION_INDEX Date 2 1970 case 0x0071: // PR_CONVERSATION_INDEX Date 2
1838 DEBUG_EMAIL(("Conversation Index - ")); 1971 DEBUG_EMAIL(("Conversation Index - "));
1839 MALLOC_EMAIL(item); 1972 MALLOC_EMAIL(item);
1840 memcpy(&(item->email->conv_index), list->items[x]->data, sizeof(item->email->conv_index)); 1973 memcpy(&(item->email->conv_index), list->items[x]->data, sizeof(item->email->conv_index));
1841 DEBUG_EMAIL(("%i\n", item->email->conv_index)); 1974 DEBUG_EMAIL(("%i\n", item->email->conv_index));
1842 break; 1975 break;
1843 case 0x0075: // PR_RECEIVED_BY_ADDRTYPE Recipient Access Method 1976 case 0x0075: // PR_RECEIVED_BY_ADDRTYPE Recipient Access Method
1844 DEBUG_EMAIL(("Received by Address type - ")); 1977 DEBUG_EMAIL(("Received by Address type - "));
1845 MALLOC_EMAIL(item); 1978 MALLOC_EMAIL(item);
1846 LIST_COPY(item->email->recip_access, (char*)); 1979 LIST_COPY(item->email->recip_access, (char*));
1847 DEBUG_EMAIL(("%s\n", item->email->recip_access)); 1980 DEBUG_EMAIL(("%s\n", item->email->recip_access));
1848 break; 1981 break;
1849 case 0x0076: // PR_RECEIVED_BY_EMAIL_ADDRESS Recipient Address 1982 case 0x0076: // PR_RECEIVED_BY_EMAIL_ADDRESS Recipient Address
1850 DEBUG_EMAIL(("Received by Address - ")); 1983 DEBUG_EMAIL(("Received by Address - "));
1851 MALLOC_EMAIL(item); 1984 MALLOC_EMAIL(item);
1852 LIST_COPY(item->email->recip_address, (char*)); 1985 LIST_COPY(item->email->recip_address, (char*));
1853 DEBUG_EMAIL(("%s\n", item->email->recip_address)); 1986 DEBUG_EMAIL(("%s\n", item->email->recip_address));
1854 break; 1987 break;
1855 case 0x0077: // PR_RCVD_REPRESENTING_ADDRTYPE Recipient Access Method 2 1988 case 0x0077: // PR_RCVD_REPRESENTING_ADDRTYPE Recipient Access Method 2
1856 DEBUG_EMAIL(("Received on behalf of Address type - ")); 1989 DEBUG_EMAIL(("Received on behalf of Address type - "));
1857 MALLOC_EMAIL(item); 1990 MALLOC_EMAIL(item);
1858 LIST_COPY(item->email->recip2_access, (char*)); 1991 LIST_COPY(item->email->recip2_access, (char*));
1859 DEBUG_EMAIL(("%s\n", item->email->recip2_access)); 1992 DEBUG_EMAIL(("%s\n", item->email->recip2_access));
1860 break; 1993 break;
1861 case 0x0078: // PR_RCVD_REPRESENTING_EMAIL_ADDRESS Recipient Address 2 1994 case 0x0078: // PR_RCVD_REPRESENTING_EMAIL_ADDRESS Recipient Address 2
1862 DEBUG_EMAIL(("Received on behalf of Address -")); 1995 DEBUG_EMAIL(("Received on behalf of Address -"));
1863 MALLOC_EMAIL(item); 1996 MALLOC_EMAIL(item);
1864 LIST_COPY(item->email->recip2_address, (char*)); 1997 LIST_COPY(item->email->recip2_address, (char*));
1865 DEBUG_EMAIL(("%s\n", item->email->recip2_address)); 1998 DEBUG_EMAIL(("%s\n", item->email->recip2_address));
1866 break; 1999 break;
1867 case 0x007D: // PR_TRANSPORT_MESSAGE_HEADERS Internet Header 2000 case 0x007D: // PR_TRANSPORT_MESSAGE_HEADERS Internet Header
1868 DEBUG_EMAIL(("Internet Header - ")); 2001 DEBUG_EMAIL(("Internet Header - "));
1869 MALLOC_EMAIL(item); 2002 MALLOC_EMAIL(item);
1870 LIST_COPY(item->email->header, (char*)); 2003 LIST_COPY(item->email->header, (char*));
1871 //DEBUG_EMAIL(("%s\n", item->email->header)); 2004 //DEBUG_EMAIL(("%s\n", item->email->header));
1872 DEBUG_EMAIL(("NOT PRINTED\n")); 2005 DEBUG_EMAIL(("NOT PRINTED\n"));
1873 break; 2006 break;
1874 case 0x0C17: // PR_REPLY_REQUESTED 2007 case 0x0C17: // PR_REPLY_REQUESTED
1875 DEBUG_EMAIL(("Reply Requested - ")); 2008 DEBUG_EMAIL(("Reply Requested - "));
1876 MALLOC_EMAIL(item); 2009 MALLOC_EMAIL(item);
1877 if (*(int16_t*)list->items[x]->data != 0) { 2010 if (*(int16_t*)list->items[x]->data != 0) {
1878 DEBUG_EMAIL(("True\n")); 2011 DEBUG_EMAIL(("True\n"));
1879 item->email->reply_requested = 1; 2012 item->email->reply_requested = 1;
1880 } else { 2013 } else {
1881 DEBUG_EMAIL(("False\n")); 2014 DEBUG_EMAIL(("False\n"));
1882 item->email->reply_requested = 0; 2015 item->email->reply_requested = 0;
1883 } 2016 }
1884 break; 2017 break;
1885 case 0x0C19: // PR_SENDER_ENTRYID Sender Structure 2 2018 case 0x0C19: // PR_SENDER_ENTRYID Sender Structure 2
1886 DEBUG_EMAIL(("Sender Structure 2 -- NOT HANDLED\n")); 2019 DEBUG_EMAIL(("Sender Structure 2 -- NOT HANDLED\n"));
1887 break; 2020 break;
1888 case 0x0C1A: // PR_SENDER_NAME Name of Sender Structure 2 2021 case 0x0C1A: // PR_SENDER_NAME Name of Sender Structure 2
1889 DEBUG_EMAIL(("Name of Sender Structure 2 -- NOT HANDLED\n")); 2022 DEBUG_EMAIL(("Name of Sender Structure 2 -- NOT HANDLED\n"));
1890 break; 2023 break;
1891 case 0x0C1D: // PR_SENDER_SEARCH_KEY Name of Sender Address 2 2024 case 0x0C1D: // PR_SENDER_SEARCH_KEY Name of Sender Address 2
1892 DEBUG_EMAIL(("Name of Sender Address 2 (Sender search key) - ")); 2025 DEBUG_EMAIL(("Name of Sender Address 2 (Sender search key) - "));
1893 MALLOC_EMAIL(item); 2026 MALLOC_EMAIL(item);
1894 LIST_COPY(item->email->outlook_sender2, (char*)); 2027 LIST_COPY(item->email->outlook_sender2, (char*));
1895 DEBUG_EMAIL(("%s\n", item->email->outlook_sender2)); 2028 DEBUG_EMAIL(("%s\n", item->email->outlook_sender2));
1896 break; 2029 break;
1897 case 0x0C1E: // PR_SENDER_ADDRTYPE Sender Address 2 access method 2030 case 0x0C1E: // PR_SENDER_ADDRTYPE Sender Address 2 access method
1898 DEBUG_EMAIL(("Sender Address type - ")); 2031 DEBUG_EMAIL(("Sender Address type - "));
1899 MALLOC_EMAIL(item); 2032 MALLOC_EMAIL(item);
1900 LIST_COPY(item->email->sender2_access, (char*)); 2033 LIST_COPY(item->email->sender2_access, (char*));
1901 DEBUG_EMAIL(("%s\n", item->email->sender2_access)); 2034 DEBUG_EMAIL(("%s\n", item->email->sender2_access));
1902 break; 2035 break;
1903 case 0x0C1F: // PR_SENDER_EMAIL_ADDRESS Sender Address 2 2036 case 0x0C1F: // PR_SENDER_EMAIL_ADDRESS Sender Address 2
1904 DEBUG_EMAIL(("Sender Address - ")); 2037 DEBUG_EMAIL(("Sender Address - "));
1905 MALLOC_EMAIL(item); 2038 MALLOC_EMAIL(item);
1906 LIST_COPY(item->email->sender2_address, (char*)); 2039 LIST_COPY(item->email->sender2_address, (char*));
1907 DEBUG_EMAIL(("%s\n", item->email->sender2_address)); 2040 DEBUG_EMAIL(("%s\n", item->email->sender2_address));
1908 break; 2041 break;
1909 case 0x0E01: // PR_DELETE_AFTER_SUBMIT 2042 case 0x0E01: // PR_DELETE_AFTER_SUBMIT
1910 // I am not too sure how this works 2043 // I am not too sure how this works
1911 DEBUG_EMAIL(("Delete after submit - ")); 2044 DEBUG_EMAIL(("Delete after submit - "));
1912 MALLOC_EMAIL(item); 2045 MALLOC_EMAIL(item);
1913 if (*(int16_t*) list->items[x]->data != 0) { 2046 if (*(int16_t*) list->items[x]->data != 0) {
1914 DEBUG_EMAIL(("True\n")); 2047 DEBUG_EMAIL(("True\n"));
1915 item->email->delete_after_submit = 1; 2048 item->email->delete_after_submit = 1;
1916 } else { 2049 } else {
1917 DEBUG_EMAIL(("False\n")); 2050 DEBUG_EMAIL(("False\n"));
1918 item->email->delete_after_submit = 0; 2051 item->email->delete_after_submit = 0;
1919 } 2052 }
1920 break; 2053 break;
1921 case 0x0E03: // PR_DISPLAY_CC CC Addresses 2054 case 0x0E03: // PR_DISPLAY_CC CC Addresses
1922 DEBUG_EMAIL(("Display CC Addresses - ")); 2055 DEBUG_EMAIL(("Display CC Addresses - "));
1923 MALLOC_EMAIL(item); 2056 MALLOC_EMAIL(item);
1924 LIST_COPY(item->email->cc_address, (char*)); 2057 LIST_COPY(item->email->cc_address, (char*));
1925 DEBUG_EMAIL(("%s\n", item->email->cc_address)); 2058 DEBUG_EMAIL(("%s\n", item->email->cc_address));
1926 break; 2059 break;
1927 case 0x0E04: // PR_DISPLAY_TO Address Sent-To 2060 case 0x0E04: // PR_DISPLAY_TO Address Sent-To
1928 DEBUG_EMAIL(("Display Sent-To Address - ")); 2061 DEBUG_EMAIL(("Display Sent-To Address - "));
1929 MALLOC_EMAIL(item); 2062 MALLOC_EMAIL(item);
1930 LIST_COPY(item->email->sentto_address, (char*)); 2063 LIST_COPY(item->email->sentto_address, (char*));
1931 DEBUG_EMAIL(("%s\n", item->email->sentto_address)); 2064 DEBUG_EMAIL(("%s\n", item->email->sentto_address));
1932 break; 2065 break;
1933 case 0x0E06: // PR_MESSAGE_DELIVERY_TIME Date 3 - Email Arrival Date 2066 case 0x0E06: // PR_MESSAGE_DELIVERY_TIME Date 3 - Email Arrival Date
1934 DEBUG_EMAIL(("Date 3 (Delivery Time) - ")); 2067 DEBUG_EMAIL(("Date 3 (Delivery Time) - "));
1935 MALLOC_EMAIL(item); 2068 MALLOC_EMAIL(item);
1936 LIST_COPY(item->email->arrival_date, (FILETIME*)); 2069 LIST_COPY(item->email->arrival_date, (FILETIME*));
1937 DEBUG_EMAIL(("%s", fileTimeToAscii(item->email->arrival_date))); 2070 DEBUG_EMAIL(("%s", fileTimeToAscii(item->email->arrival_date)));
1938 break; 2071 break;
1939 case 0x0E07: // PR_MESSAGE_FLAGS Email Flag 2072 case 0x0E07: // PR_MESSAGE_FLAGS Email Flag
1940 // 0x01 - Read 2073 // 0x01 - Read
1941 // 0x02 - Unmodified 2074 // 0x02 - Unmodified
1942 // 0x04 - Submit 2075 // 0x04 - Submit
1943 // 0x08 - Unsent 2076 // 0x08 - Unsent
1944 // 0x10 - Has Attachments 2077 // 0x10 - Has Attachments
1945 // 0x20 - From Me 2078 // 0x20 - From Me
1946 // 0x40 - Associated 2079 // 0x40 - Associated
1947 // 0x80 - Resend 2080 // 0x80 - Resend
1948 // 0x100 - RN Pending 2081 // 0x100 - RN Pending
1949 // 0x200 - NRN Pending 2082 // 0x200 - NRN Pending
1950 DEBUG_EMAIL(("Message Flags - ")); 2083 DEBUG_EMAIL(("Message Flags - "));
1951 MALLOC_EMAIL(item); 2084 MALLOC_EMAIL(item);
1952 memcpy(&(item->email->flag), list->items[x]->data, sizeof(item->email->flag)); 2085 memcpy(&(item->email->flag), list->items[x]->data, sizeof(item->email->flag));
1953 LE32_CPU(item->email->flag); 2086 LE32_CPU(item->email->flag);
1954 DEBUG_EMAIL(("%i\n", item->email->flag)); 2087 DEBUG_EMAIL(("%i\n", item->email->flag));
1955 break; 2088 break;
1956 case 0x0E08: // PR_MESSAGE_SIZE Total size of a message object 2089 case 0x0E08: // PR_MESSAGE_SIZE Total size of a message object
1957 DEBUG_EMAIL(("Message Size - ")); 2090 DEBUG_EMAIL(("Message Size - "));
1958 memcpy(&(item->message_size), list->items[x]->data, sizeof(item->message_size)); 2091 memcpy(&(item->message_size), list->items[x]->data, sizeof(item->message_size));
1959 LE32_CPU(item->message_size); 2092 LE32_CPU(item->message_size);
1960 DEBUG_EMAIL(("%i [%#x]\n", item->message_size, item->message_size)); 2093 DEBUG_EMAIL(("%i [%#x]\n", item->message_size, item->message_size));
1961 break; 2094 break;
1962 case 0x0E0A: // PR_SENTMAIL_ENTRYID 2095 case 0x0E0A: // PR_SENTMAIL_ENTRYID
1963 // folder that this message is sent to after submission 2096 // folder that this message is sent to after submission
1964 DEBUG_EMAIL(("Sentmail EntryID - ")); 2097 DEBUG_EMAIL(("Sentmail EntryID - "));
1965 MALLOC_EMAIL(item); 2098 MALLOC_EMAIL(item);
1966 LIST_COPY(item->email->sentmail_folder, (pst_entryid*)); 2099 LIST_COPY(item->email->sentmail_folder, (pst_entryid*));
1967 LE32_CPU(item->email->sentmail_folder->id); 2100 LE32_CPU(item->email->sentmail_folder->id);
1968 DEBUG_EMAIL(("[id = %#x]\n", item->email->sentmail_folder->id)); 2101 DEBUG_EMAIL(("[id = %#x]\n", item->email->sentmail_folder->id));
1969 break; 2102 break;
1970 case 0x0E1F: // PR_RTF_IN_SYNC 2103 case 0x0E1F: // PR_RTF_IN_SYNC
1971 // True means that the rtf version is same as text body 2104 // True means that the rtf version is same as text body
1972 // False means rtf version is more up-to-date than text body 2105 // False means rtf version is more up-to-date than text body
1973 // if this value doesn't exist, text body is more up-to-date than rtf and 2106 // if this value doesn't exist, text body is more up-to-date than rtf and
1974 // cannot update to the rtf 2107 // cannot update to the rtf
1975 DEBUG_EMAIL(("Compressed RTF in Sync - ")); 2108 DEBUG_EMAIL(("Compressed RTF in Sync - "));
1976 MALLOC_EMAIL(item); 2109 MALLOC_EMAIL(item);
1977 if (*(int16_t*)list->items[x]->data != 0) { 2110 if (*(int16_t*)list->items[x]->data != 0) {
1978 DEBUG_EMAIL(("True\n")); 2111 DEBUG_EMAIL(("True\n"));
1979 item->email->rtf_in_sync = 1; 2112 item->email->rtf_in_sync = 1;
1980 } else { 2113 } else {
1981 DEBUG_EMAIL(("False\n")); 2114 DEBUG_EMAIL(("False\n"));
1982 item->email->rtf_in_sync = 0; 2115 item->email->rtf_in_sync = 0;
1983 } 2116 }
1984 break; 2117 break;
1985 case 0x0E20: // PR_ATTACH_SIZE binary Attachment data in record 2118 case 0x0E20: // PR_ATTACH_SIZE binary Attachment data in record
1986 DEBUG_EMAIL(("Attachment Size - ")); 2119 DEBUG_EMAIL(("Attachment Size - "));
1987 NULL_CHECK(attach); 2120 NULL_CHECK(attach);
1988 MOVE_NEXT(attach); 2121 MOVE_NEXT(attach);
1989 memcpy(&(attach->size), list->items[x]->data, sizeof(attach->size)); 2122 memcpy(&(attach->size), list->items[x]->data, sizeof(attach->size));
1990 DEBUG_EMAIL(("%i\n", attach->size)); 2123 DEBUG_EMAIL(("%i\n", attach->size));
1991 break; 2124 break;
1992 case 0x0FF9: // PR_RECORD_KEY Record Header 1 2125 case 0x0FF9: // PR_RECORD_KEY Record Header 1
1993 DEBUG_EMAIL(("Record Key 1 - ")); 2126 DEBUG_EMAIL(("Record Key 1 - "));
1994 LIST_COPY(item->record_key, (char*)); 2127 LIST_COPY(item->record_key, (char*));
1995 item->record_key_size = list->items[x]->size; 2128 item->record_key_size = list->items[x]->size;
1996 DEBUG_EMAIL_HEXPRINT(item->record_key, item->record_key_size); 2129 DEBUG_EMAIL_HEXPRINT(item->record_key, item->record_key_size);
1997 DEBUG_EMAIL(("\n")); 2130 DEBUG_EMAIL(("\n"));
1998 break; 2131 break;
1999 case 0x1000: // PR_BODY Plain Text body 2132 case 0x1000: // PR_BODY Plain Text body
2000 DEBUG_EMAIL(("Plain Text body - ")); 2133 DEBUG_EMAIL(("Plain Text body - "));
2001 MALLOC_EMAIL(item); 2134 MALLOC_EMAIL(item);
2002 LIST_COPY(item->email->body, (char*)); 2135 LIST_COPY(item->email->body, (char*));
2003 //DEBUG_EMAIL("%s\n", item->email->body); 2136 //DEBUG_EMAIL("%s\n", item->email->body);
2004 DEBUG_EMAIL(("NOT PRINTED\n")); 2137 DEBUG_EMAIL(("NOT PRINTED\n"));
2005 break; 2138 break;
2006 case 0x1006: // PR_RTF_SYNC_BODY_CRC 2139 case 0x1006: // PR_RTF_SYNC_BODY_CRC
2007 DEBUG_EMAIL(("RTF Sync Body CRC - ")); 2140 DEBUG_EMAIL(("RTF Sync Body CRC - "));
2008 MALLOC_EMAIL(item); 2141 MALLOC_EMAIL(item);
2009 memcpy(&(item->email->rtf_body_crc), list->items[x]->data, sizeof(item->email->rtf_body_crc)); 2142 memcpy(&(item->email->rtf_body_crc), list->items[x]->data, sizeof(item->email->rtf_body_crc));
2010 LE32_CPU(item->email->rtf_body_crc); 2143 LE32_CPU(item->email->rtf_body_crc);
2011 DEBUG_EMAIL(("%#x\n", item->email->rtf_body_crc)); 2144 DEBUG_EMAIL(("%#x\n", item->email->rtf_body_crc));
2012 break; 2145 break;
2013 case 0x1007: // PR_RTF_SYNC_BODY_COUNT 2146 case 0x1007: // PR_RTF_SYNC_BODY_COUNT
2014 // a count of the *significant* charcters in the rtf body. Doesn't count 2147 // a count of the *significant* charcters in the rtf body. Doesn't count
2015 // whitespace and other ignorable characters 2148 // whitespace and other ignorable characters
2016 DEBUG_EMAIL(("RTF Sync Body character count - ")); 2149 DEBUG_EMAIL(("RTF Sync Body character count - "));
2017 MALLOC_EMAIL(item); 2150 MALLOC_EMAIL(item);
2018 memcpy(&(item->email->rtf_body_char_count), list->items[x]->data, sizeof(item->email->rtf_body_char_count)); 2151 memcpy(&(item->email->rtf_body_char_count), list->items[x]->data, sizeof(item->email->rtf_body_char_count));
2019 LE32_CPU(item->email->rtf_body_char_count); 2152 LE32_CPU(item->email->rtf_body_char_count);
2020 DEBUG_EMAIL(("%i [%#x]\n", item->email->rtf_body_char_count, item->email->rtf_body_char_count)); 2153 DEBUG_EMAIL(("%i [%#x]\n", item->email->rtf_body_char_count, item->email->rtf_body_char_count));
2021 break; 2154 break;
2022 case 0x1008: // PR_RTF_SYNC_BODY_TAG 2155 case 0x1008: // PR_RTF_SYNC_BODY_TAG
2023 // the first couple of lines of RTF body so that after modification, then beginning can 2156 // the first couple of lines of RTF body so that after modification, then beginning can
2024 // once again be found 2157 // once again be found
2025 DEBUG_EMAIL(("RTF Sync body tag - ")); 2158 DEBUG_EMAIL(("RTF Sync body tag - "));
2026 MALLOC_EMAIL(item); 2159 MALLOC_EMAIL(item);
2027 LIST_COPY(item->email->rtf_body_tag, (char*)); 2160 LIST_COPY(item->email->rtf_body_tag, (char*));
2028 DEBUG_EMAIL(("%s\n", item->email->rtf_body_tag)); 2161 DEBUG_EMAIL(("%s\n", item->email->rtf_body_tag));
2029 break; 2162 break;
2030 case 0x1009: // PR_RTF_COMPRESSED 2163 case 0x1009: // PR_RTF_COMPRESSED
2031 // some compression algorithm has been applied to this. At present 2164 // some compression algorithm has been applied to this. At present
2032 // it is unknown 2165 // it is unknown
2033 DEBUG_EMAIL(("RTF Compressed body - ")); 2166 DEBUG_EMAIL(("RTF Compressed body - "));
2034 MALLOC_EMAIL(item); 2167 MALLOC_EMAIL(item);
2035 LIST_COPY_SIZE(item->email->rtf_compressed, (char*), item->email->rtf_compressed_size); 2168 LIST_COPY_SIZE(item->email->rtf_compressed, (char*), item->email->rtf_compressed_size);
2036 DEBUG_EMAIL(("NOT PRINTED\n")); 2169 DEBUG_EMAIL(("NOT PRINTED\n"));
2037 break; 2170 break;
2038 case 0x1010: // PR_RTF_SYNC_PREFIX_COUNT 2171 case 0x1010: // PR_RTF_SYNC_PREFIX_COUNT
2039 // a count of the ignored characters before the first significant character 2172 // a count of the ignored characters before the first significant character
2040 DEBUG_EMAIL(("RTF whitespace prefix count - ")); 2173 DEBUG_EMAIL(("RTF whitespace prefix count - "));
2041 MALLOC_EMAIL(item); 2174 MALLOC_EMAIL(item);
2042 memcpy(&(item->email->rtf_ws_prefix_count), list->items[x]->data, sizeof(item->email->rtf_ws_prefix_count)); 2175 memcpy(&(item->email->rtf_ws_prefix_count), list->items[x]->data, sizeof(item->email->rtf_ws_prefix_count));
2043 DEBUG_EMAIL(("%i\n", item->email->rtf_ws_prefix_count)); 2176 DEBUG_EMAIL(("%i\n", item->email->rtf_ws_prefix_count));
2044 break; 2177 break;
2045 case 0x1011: // PR_RTF_SYNC_TRAILING_COUNT 2178 case 0x1011: // PR_RTF_SYNC_TRAILING_COUNT
2046 // a count of the ignored characters after the last significant character 2179 // a count of the ignored characters after the last significant character
2047 DEBUG_EMAIL(("RTF whitespace tailing count - ")); 2180 DEBUG_EMAIL(("RTF whitespace tailing count - "));
2048 MALLOC_EMAIL(item); 2181 MALLOC_EMAIL(item);
2049 memcpy(&(item->email->rtf_ws_trailing_count), list->items[x]->data, sizeof(item->email->rtf_ws_trailing_count)); 2182 memcpy(&(item->email->rtf_ws_trailing_count), list->items[x]->data, sizeof(item->email->rtf_ws_trailing_count));
2050 DEBUG_EMAIL(("%i\n", item->email->rtf_ws_trailing_count)); 2183 DEBUG_EMAIL(("%i\n", item->email->rtf_ws_trailing_count));
2051 break; 2184 break;
2052 case 0x1013: // HTML body 2185 case 0x1013: // HTML body
2053 DEBUG_EMAIL(("HTML body - ")); 2186 DEBUG_EMAIL(("HTML body - "));
2054 MALLOC_EMAIL(item); 2187 MALLOC_EMAIL(item);
2055 LIST_COPY(item->email->htmlbody, (char*)); 2188 LIST_COPY(item->email->htmlbody, (char*));
2056 // DEBUG_EMAIL(("%s\n", item->email->htmlbody)); 2189 // DEBUG_EMAIL(("%s\n", item->email->htmlbody));
2057 DEBUG_EMAIL(("NOT PRINTED\n")); 2190 DEBUG_EMAIL(("NOT PRINTED\n"));
2058 break; 2191 break;
2059 case 0x1035: // Message ID 2192 case 0x1035: // Message ID
2060 DEBUG_EMAIL(("Message ID - ")); 2193 DEBUG_EMAIL(("Message ID - "));
2061 MALLOC_EMAIL(item); 2194 MALLOC_EMAIL(item);
2062 LIST_COPY(item->email->messageid, (char*)); 2195 LIST_COPY(item->email->messageid, (char*));
2063 DEBUG_EMAIL(("%s\n", item->email->messageid)); 2196 DEBUG_EMAIL(("%s\n", item->email->messageid));
2064 break; 2197 break;
2065 case 0x1042: // in-reply-to 2198 case 0x1042: // in-reply-to
2066 DEBUG_EMAIL(("In-Reply-To - ")); 2199 DEBUG_EMAIL(("In-Reply-To - "));
2067 MALLOC_EMAIL(item); 2200 MALLOC_EMAIL(item);
2068 LIST_COPY(item->email->in_reply_to, (char*)); 2201 LIST_COPY(item->email->in_reply_to, (char*));
2069 DEBUG_EMAIL(("%s\n", item->email->in_reply_to)); 2202 DEBUG_EMAIL(("%s\n", item->email->in_reply_to));
2070 break; 2203 break;
2071 case 0x1046: // Return Path 2204 case 0x1046: // Return Path
2072 DEBUG_EMAIL(("Return Path - ")); 2205 DEBUG_EMAIL(("Return Path - "));
2073 MALLOC_EMAIL(item); 2206 MALLOC_EMAIL(item);
2074 LIST_COPY(item->email->return_path_address, (char*)); 2207 LIST_COPY(item->email->return_path_address, (char*));
2075 DEBUG_EMAIL(("%s\n", item->email->return_path_address)); 2208 DEBUG_EMAIL(("%s\n", item->email->return_path_address));
2076 break; 2209 break;
2077 case 0x3001: // PR_DISPLAY_NAME File As 2210 case 0x3001: // PR_DISPLAY_NAME File As
2078 DEBUG_EMAIL(("Display Name - ")); 2211 DEBUG_EMAIL(("Display Name - "));
2079 LIST_COPY(item->file_as, (char*)); 2212 LIST_COPY(item->file_as, (char*));
2080 DEBUG_EMAIL(("%s\n", item->file_as)); 2213 DEBUG_EMAIL(("%s\n", item->file_as));
2081 break; 2214 break;
2082 case 0x3002: // PR_ADDRTYPE 2215 case 0x3002: // PR_ADDRTYPE
2083 DEBUG_EMAIL(("Address Type - ")); 2216 DEBUG_EMAIL(("Address Type - "));
2084 MALLOC_CONTACT(item); 2217 MALLOC_CONTACT(item);
2085 LIST_COPY(item->contact->address1_transport, (char*)); 2218 LIST_COPY(item->contact->address1_transport, (char*));
2086 DEBUG_EMAIL(("|%s|\n", item->contact->address1_transport)); 2219 DEBUG_EMAIL(("|%s|\n", item->contact->address1_transport));
2087 break; 2220 break;
2088 case 0x3003: // PR_EMAIL_ADDRESS 2221 case 0x3003: // PR_EMAIL_ADDRESS
2089 // Contact's email address 2222 // Contact's email address
2090 DEBUG_EMAIL(("Contact Address - ")); 2223 DEBUG_EMAIL(("Contact Address - "));
2091 MALLOC_CONTACT(item); 2224 MALLOC_CONTACT(item);
2092 LIST_COPY(item->contact->address1, (char*)); 2225 LIST_COPY(item->contact->address1, (char*));
2093 DEBUG_EMAIL(("|%s|\n", item->contact->address1)); 2226 DEBUG_EMAIL(("|%s|\n", item->contact->address1));
2094 break; 2227 break;
2095 case 0x3004: // PR_COMMENT Comment for item - usually folders 2228 case 0x3004: // PR_COMMENT Comment for item - usually folders
2096 DEBUG_EMAIL(("Comment - ")); 2229 DEBUG_EMAIL(("Comment - "));
2097 LIST_COPY(item->comment, (char*)); 2230 LIST_COPY(item->comment, (char*));
2098 DEBUG_EMAIL(("%s\n", item->comment)); 2231 DEBUG_EMAIL(("%s\n", item->comment));
2099 break; 2232 break;
2100 case 0x3007: // PR_CREATION_TIME Date 4 - Creation Date? 2233 case 0x3007: // PR_CREATION_TIME Date 4 - Creation Date?
2101 DEBUG_EMAIL(("Date 4 (Item Creation Date) - ")); 2234 DEBUG_EMAIL(("Date 4 (Item Creation Date) - "));
2102 LIST_COPY(item->create_date, (FILETIME*)); 2235 LIST_COPY(item->create_date, (FILETIME*));
2103 DEBUG_EMAIL(("%s", fileTimeToAscii(item->create_date))); 2236 DEBUG_EMAIL(("%s", fileTimeToAscii(item->create_date)));
2104 break; 2237 break;
2105 case 0x3008: // PR_LAST_MODIFICATION_TIME Date 5 - Modify Date 2238 case 0x3008: // PR_LAST_MODIFICATION_TIME Date 5 - Modify Date
2106 DEBUG_EMAIL(("Date 5 (Modify Date) - ")); 2239 DEBUG_EMAIL(("Date 5 (Modify Date) - "));
2107 LIST_COPY(item->modify_date, (FILETIME*)); 2240 LIST_COPY(item->modify_date, (FILETIME*));
2108 DEBUG_EMAIL(("%s", fileTimeToAscii(item->modify_date))); 2241 DEBUG_EMAIL(("%s", fileTimeToAscii(item->modify_date)));
2109 break; 2242 break;
2110 case 0x300B: // PR_SEARCH_KEY Record Header 2 2243 case 0x300B: // PR_SEARCH_KEY Record Header 2
2111 DEBUG_EMAIL(("Record Search 2 -- NOT HANDLED\n")); 2244 DEBUG_EMAIL(("Record Search 2 -- NOT HANDLED\n"));
2112 break; 2245 break;
2113 case 0x35DF: // PR_VALID_FOLDER_MASK 2246 case 0x35DF: // PR_VALID_FOLDER_MASK
2114 // States which folders are valid for this message store 2247 // States which folders are valid for this message store
2115 // FOLDER_IPM_SUBTREE_VALID 0x1 2248 // FOLDER_IPM_SUBTREE_VALID 0x1
2116 // FOLDER_IPM_INBOX_VALID 0x2 2249 // FOLDER_IPM_INBOX_VALID 0x2
2117 // FOLDER_IPM_OUTBOX_VALID 0x4 2250 // FOLDER_IPM_OUTBOX_VALID 0x4
2118 // FOLDER_IPM_WASTEBOX_VALID 0x8 2251 // FOLDER_IPM_WASTEBOX_VALID 0x8
2119 // FOLDER_IPM_SENTMAIL_VALID 0x10 2252 // FOLDER_IPM_SENTMAIL_VALID 0x10
2120 // FOLDER_VIEWS_VALID 0x20 2253 // FOLDER_VIEWS_VALID 0x20
2121 // FOLDER_COMMON_VIEWS_VALID 0x40 2254 // FOLDER_COMMON_VIEWS_VALID 0x40
2122 // FOLDER_FINDER_VALID 0x80 2255 // FOLDER_FINDER_VALID 0x80
2123 DEBUG_EMAIL(("Valid Folder Mask - ")); 2256 DEBUG_EMAIL(("Valid Folder Mask - "));
2124 MALLOC_MESSAGESTORE(item); 2257 MALLOC_MESSAGESTORE(item);
2125 memcpy(&(item->message_store->valid_mask), list->items[x]->data, sizeof(int)); 2258 memcpy(&(item->message_store->valid_mask), list->items[x]->data, sizeof(int));
2126 LE32_CPU(item->message_store->valid_mask); 2259 LE32_CPU(item->message_store->valid_mask);
2127 DEBUG_EMAIL(("%i\n", item->message_store->valid_mask)); 2260 DEBUG_EMAIL(("%i\n", item->message_store->valid_mask));
2128 break; 2261 break;
2129 case 0x35E0: // PR_IPM_SUBTREE_ENTRYID Top of Personal Folder Record 2262 case 0x35E0: // PR_IPM_SUBTREE_ENTRYID Top of Personal Folder Record
2130 DEBUG_EMAIL(("Top of Personal Folder Record - ")); 2263 DEBUG_EMAIL(("Top of Personal Folder Record - "));
2131 MALLOC_MESSAGESTORE(item); 2264 MALLOC_MESSAGESTORE(item);
2132 LIST_COPY(item->message_store->top_of_personal_folder, (pst_entryid*)); 2265 LIST_COPY(item->message_store->top_of_personal_folder, (pst_entryid*));
2133 LE32_CPU(item->message_store->top_of_personal_folder->id); 2266 LE32_CPU(item->message_store->top_of_personal_folder->id);
2134 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->top_of_personal_folder->id)); 2267 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->top_of_personal_folder->id));
2135 break; 2268 break;
2136 case 0x35E3: // PR_IPM_WASTEBASKET_ENTRYID Deleted Items Folder Record 2269 case 0x35E3: // PR_IPM_WASTEBASKET_ENTRYID Deleted Items Folder Record
2137 DEBUG_EMAIL(("Deleted Items Folder record - ")); 2270 DEBUG_EMAIL(("Deleted Items Folder record - "));
2138 MALLOC_MESSAGESTORE(item); 2271 MALLOC_MESSAGESTORE(item);
2139 LIST_COPY(item->message_store->deleted_items_folder, (pst_entryid*)); 2272 LIST_COPY(item->message_store->deleted_items_folder, (pst_entryid*));
2140 LE32_CPU(item->message_store->deleted_items_folder->id); 2273 LE32_CPU(item->message_store->deleted_items_folder->id);
2141 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->deleted_items_folder->id)); 2274 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->deleted_items_folder->id));
2142 break; 2275 break;
2143 case 0x35E7: // PR_FINDER_ENTRYID Search Root Record 2276 case 0x35E7: // PR_FINDER_ENTRYID Search Root Record
2144 DEBUG_EMAIL(("Search Root record - ")); 2277 DEBUG_EMAIL(("Search Root record - "));
2145 MALLOC_MESSAGESTORE(item); 2278 MALLOC_MESSAGESTORE(item);
2146 LIST_COPY(item->message_store->search_root_folder, (pst_entryid*)); 2279 LIST_COPY(item->message_store->search_root_folder, (pst_entryid*));
2147 LE32_CPU(item->message_store->search_root_folder->id); 2280 LE32_CPU(item->message_store->search_root_folder->id);
2148 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->search_root_folder->id)); 2281 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->search_root_folder->id));
2149 break; 2282 break;
2150 case 0x3602: // PR_CONTENT_COUNT Number of emails stored in a folder 2283 case 0x3602: // PR_CONTENT_COUNT Number of emails stored in a folder
2151 DEBUG_EMAIL(("Folder Email Count - ")); 2284 DEBUG_EMAIL(("Folder Email Count - "));
2152 MALLOC_FOLDER(item); 2285 MALLOC_FOLDER(item);
2153 memcpy(&(item->folder->email_count), list->items[x]->data, sizeof(item->folder->email_count)); 2286 memcpy(&(item->folder->email_count), list->items[x]->data, sizeof(item->folder->email_count));
2154 LE32_CPU(item->folder->email_count); 2287 LE32_CPU(item->folder->email_count);
2155 DEBUG_EMAIL(("%i\n", item->folder->email_count)); 2288 DEBUG_EMAIL(("%i\n", item->folder->email_count));
2156 break; 2289 break;
2157 case 0x3603: // PR_CONTENT_UNREAD Number of unread emails 2290 case 0x3603: // PR_CONTENT_UNREAD Number of unread emails
2158 DEBUG_EMAIL(("Unread Email Count - ")); 2291 DEBUG_EMAIL(("Unread Email Count - "));
2159 MALLOC_FOLDER(item); 2292 MALLOC_FOLDER(item);
2160 memcpy(&(item->folder->unseen_email_count), list->items[x]->data, sizeof(item->folder->unseen_email_count)); 2293 memcpy(&(item->folder->unseen_email_count), list->items[x]->data, sizeof(item->folder->unseen_email_count));
2161 LE32_CPU(item->folder->unseen_email_count); 2294 LE32_CPU(item->folder->unseen_email_count);
2162 DEBUG_EMAIL(("%i\n", item->folder->unseen_email_count)); 2295 DEBUG_EMAIL(("%i\n", item->folder->unseen_email_count));
2163 break; 2296 break;
2164 case 0x360A: // PR_SUBFOLDERS Has children 2297 case 0x360A: // PR_SUBFOLDERS Has children
2165 DEBUG_EMAIL(("Has Subfolders - ")); 2298 DEBUG_EMAIL(("Has Subfolders - "));
2166 MALLOC_FOLDER(item); 2299 MALLOC_FOLDER(item);
2167 if (*((int32_t*)list->items[x]->data) != 0) { 2300 if (*((int32_t*)list->items[x]->data) != 0) {
2168 DEBUG_EMAIL(("True\n")); 2301 DEBUG_EMAIL(("True\n"));
2169 item->folder->subfolder = 1; 2302 item->folder->subfolder = 1;
2170 } else { 2303 } else {
2171 DEBUG_EMAIL(("False\n")); 2304 DEBUG_EMAIL(("False\n"));
2172 item->folder->subfolder = 0; 2305 item->folder->subfolder = 0;
2173 } 2306 }
2174 break; 2307 break;
2175 case 0x3613: // PR_CONTAINER_CLASS IPF.x 2308 case 0x3613: // PR_CONTAINER_CLASS IPF.x
2176 DEBUG_EMAIL(("IPF.x - ")); 2309 DEBUG_EMAIL(("IPF.x - "));
2177 LIST_COPY(item->ascii_type, (char*)); 2310 LIST_COPY(item->ascii_type, (char*));
2178 if (strncmp("IPF.Note", item->ascii_type, 8) == 0) 2311 if (strncmp("IPF.Note", item->ascii_type, 8) == 0)
2179 item->type = PST_TYPE_NOTE; 2312 item->type = PST_TYPE_NOTE;
2180 else if (strncmp("IPF.Contact", item->ascii_type, 11) == 0) 2313 else if (strncmp("IPF.Contact", item->ascii_type, 11) == 0)
2181 item->type = PST_TYPE_CONTACT; 2314 item->type = PST_TYPE_CONTACT;
2182 else if (strncmp("IPF.Journal", item->ascii_type, 11) == 0) 2315 else if (strncmp("IPF.Journal", item->ascii_type, 11) == 0)
2183 item->type = PST_TYPE_JOURNAL; 2316 item->type = PST_TYPE_JOURNAL;
2184 else if (strncmp("IPF.Appointment", item->ascii_type, 15) == 0) 2317 else if (strncmp("IPF.Appointment", item->ascii_type, 15) == 0)
2185 item->type = PST_TYPE_APPOINTMENT; 2318 item->type = PST_TYPE_APPOINTMENT;
2186 else if (strncmp("IPF.StickyNote", item->ascii_type, 14) == 0) 2319 else if (strncmp("IPF.StickyNote", item->ascii_type, 14) == 0)
2187 item->type = PST_TYPE_STICKYNOTE; 2320 item->type = PST_TYPE_STICKYNOTE;
2188 else if (strncmp("IPF.Task", item->ascii_type, 8) == 0) 2321 else if (strncmp("IPF.Task", item->ascii_type, 8) == 0)
2189 item->type = PST_TYPE_TASK; 2322 item->type = PST_TYPE_TASK;
2190 else 2323 else
2191 item->type = PST_TYPE_OTHER; 2324 item->type = PST_TYPE_OTHER;
2192 2325
2193 DEBUG_EMAIL(("%s [%i]\n", item->ascii_type, item->type)); 2326 DEBUG_EMAIL(("%s [%i]\n", item->ascii_type, item->type));
2194 break; 2327 break;
2195 case 0x3617: // PR_ASSOC_CONTENT_COUNT 2328 case 0x3617: // PR_ASSOC_CONTENT_COUNT
2196 // associated content are items that are attached to this folder 2329 // associated content are items that are attached to this folder
2197 // but are hidden from users 2330 // but are hidden from users
2198 DEBUG_EMAIL(("Associate Content count - ")); 2331 DEBUG_EMAIL(("Associate Content count - "));
2199 MALLOC_FOLDER(item); 2332 MALLOC_FOLDER(item);
2200 memcpy(&(item->folder->assoc_count), list->items[x]->data, sizeof(item->folder->assoc_count)); 2333 memcpy(&(item->folder->assoc_count), list->items[x]->data, sizeof(item->folder->assoc_count));
2201 LE32_CPU(item->folder->assoc_count); 2334 LE32_CPU(item->folder->assoc_count);
2202 DEBUG_EMAIL(("%i [%#x]\n", item->folder->assoc_count, item->folder->assoc_count)); 2335 DEBUG_EMAIL(("%i [%#x]\n", item->folder->assoc_count, item->folder->assoc_count));
2203 break; 2336 break;
2204 case 0x3701: // PR_ATTACH_DATA_OBJ binary data of attachment 2337 case 0x3701: // PR_ATTACH_DATA_OBJ binary data of attachment
2205 DEBUG_EMAIL(("Binary Data [Size %i] - ", list->items[x]->size)); 2338 DEBUG_EMAIL(("Binary Data [Size %i] - ", list->items[x]->size));
2206 NULL_CHECK(attach); 2339 NULL_CHECK(attach);
2207 MOVE_NEXT(attach); 2340 MOVE_NEXT(attach);
2208 if (!list->items[x]->data) { //special case 2341 if (!list->items[x]->data) { //special case
2209 attach->id2_val = list->items[x]->type; 2342 attach->id2_val = list->items[x]->type;
2210 DEBUG_EMAIL(("Seen a Reference. The data hasn't been loaded yet. [%#x][%#x]\n", 2343 DEBUG_EMAIL(("Seen a Reference. The data hasn't been loaded yet. [%#x][%#x]\n",
2211 attach->id2_val, list->items[x]->type)); 2344 attach->id2_val, list->items[x]->type));
2212 } else { 2345 } else {
2213 LIST_COPY(attach->data, (char*)); 2346 LIST_COPY(attach->data, (char*));
2214 attach->size = list->items[x]->size; 2347 attach->size = list->items[x]->size;
2215 DEBUG_EMAIL(("NOT PRINTED\n")); 2348 DEBUG_EMAIL(("NOT PRINTED\n"));
2216 } 2349 }
2217 break; 2350 break;
2218 case 0x3704: // PR_ATTACH_FILENAME Attachment filename (8.3) 2351 case 0x3704: // PR_ATTACH_FILENAME Attachment filename (8.3)
2219 DEBUG_EMAIL(("Attachment Filename - ")); 2352 DEBUG_EMAIL(("Attachment Filename - "));
2220 NULL_CHECK(attach); 2353 NULL_CHECK(attach);
2221 MOVE_NEXT(attach); 2354 MOVE_NEXT(attach);
2222 LIST_COPY(attach->filename1, (char*)); 2355 LIST_COPY(attach->filename1, (char*));
2223 DEBUG_EMAIL(("%s\n", attach->filename1)); 2356 DEBUG_EMAIL(("%s\n", attach->filename1));
2224 break; 2357 break;
2225 case 0x3705: // PR_ATTACH_METHOD 2358 case 0x3705: // PR_ATTACH_METHOD
2226 // 0 - No Attachment 2359 // 0 - No Attachment
2227 // 1 - Attach by Value 2360 // 1 - Attach by Value
2228 // 2 - Attach by reference 2361 // 2 - Attach by reference
2229 // 3 - Attach by ref resolve 2362 // 3 - Attach by ref resolve
2230 // 4 - Attach by ref only 2363 // 4 - Attach by ref only
2231 // 5 - Embedded Message 2364 // 5 - Embedded Message
2232 // 6 - OLE 2365 // 6 - OLE
2233 DEBUG_EMAIL(("Attachment method - ")); 2366 DEBUG_EMAIL(("Attachment method - "));
2234 NULL_CHECK(attach); 2367 NULL_CHECK(attach);
2235 MOVE_NEXT(attach); 2368 MOVE_NEXT(attach);
2236 memcpy(&(attach->method), list->items[x]->data, sizeof(attach->method)); 2369 memcpy(&(attach->method), list->items[x]->data, sizeof(attach->method));
2237 LE32_CPU(attach->method); 2370 LE32_CPU(attach->method);
2238 t = attach->method; 2371 t = attach->method;
2239 DEBUG_EMAIL(("%s [%i]\n", (t==0?"No Attachment": 2372 DEBUG_EMAIL(("%s [%i]\n", (t==0?"No Attachment":
2240 (t==1?"Attach By Value": 2373 (t==1?"Attach By Value":
2241 (t==2?"Attach By Reference": 2374 (t==2?"Attach By Reference":
2242 (t==3?"Attach by Ref. Resolve": 2375 (t==3?"Attach by Ref. Resolve":
2243 (t==4?"Attach by Ref. Only": 2376 (t==4?"Attach by Ref. Only":
2244 (t==5?"Embedded Message":"OLE")))))),t)); 2377 (t==5?"Embedded Message":"OLE")))))),t));
2245 break; 2378 break;
2246 case 0x3707: // PR_ATTACH_LONG_FILENAME Attachment filename (long?) 2379 case 0x3707: // PR_ATTACH_LONG_FILENAME Attachment filename (long?)
2247 DEBUG_EMAIL(("Attachment Filename long - ")); 2380 DEBUG_EMAIL(("Attachment Filename long - "));
2248 NULL_CHECK(attach); 2381 NULL_CHECK(attach);
2249 MOVE_NEXT(attach); 2382 MOVE_NEXT(attach);
2250 LIST_COPY(attach->filename2, (char*)); 2383 LIST_COPY(attach->filename2, (char*));
2251 DEBUG_EMAIL(("%s\n", attach->filename2)); 2384 DEBUG_EMAIL(("%s\n", attach->filename2));
2252 break; 2385 break;
2253 case 0x370B: // PR_RENDERING_POSITION 2386 case 0x370B: // PR_RENDERING_POSITION
2254 // position in characters that the attachment appears in the plain text body 2387 // position in characters that the attachment appears in the plain text body
2255 DEBUG_EMAIL(("Attachment Position - ")); 2388 DEBUG_EMAIL(("Attachment Position - "));
2256 NULL_CHECK(attach); 2389 NULL_CHECK(attach);
2257 MOVE_NEXT(attach); 2390 MOVE_NEXT(attach);
2258 memcpy(&(attach->position), list->items[x]->data, sizeof(attach->position)); 2391 memcpy(&(attach->position), list->items[x]->data, sizeof(attach->position));
2259 LE32_CPU(attach->position); 2392 LE32_CPU(attach->position);
2260 DEBUG_EMAIL(("%i [%#x]\n", attach->position)); 2393 DEBUG_EMAIL(("%i [%#x]\n", attach->position));
2261 break; 2394 break;
2262 case 0x370E: // PR_ATTACH_MIME_TAG Mime type of encoding 2395 case 0x370E: // PR_ATTACH_MIME_TAG Mime type of encoding
2263 DEBUG_EMAIL(("Attachment mime encoding - ")); 2396 DEBUG_EMAIL(("Attachment mime encoding - "));
2264 NULL_CHECK(attach); 2397 NULL_CHECK(attach);
2265 MOVE_NEXT(attach); 2398 MOVE_NEXT(attach);
2266 LIST_COPY(attach->mimetype, (char*)); 2399 LIST_COPY(attach->mimetype, (char*));
2267 DEBUG_EMAIL(("%s\n", attach->mimetype)); 2400 DEBUG_EMAIL(("%s\n", attach->mimetype));
2268 break; 2401 break;
2269 case 0x3710: // PR_ATTACH_MIME_SEQUENCE 2402 case 0x3710: // PR_ATTACH_MIME_SEQUENCE
2270 // sequence number for mime parts. Includes body 2403 // sequence number for mime parts. Includes body
2271 DEBUG_EMAIL(("Attachment Mime Sequence - ")); 2404 DEBUG_EMAIL(("Attachment Mime Sequence - "));
2272 NULL_CHECK(attach); 2405 NULL_CHECK(attach);
2273 MOVE_NEXT(attach); 2406 MOVE_NEXT(attach);
2274 memcpy(&(attach->sequence), list->items[x]->data, sizeof(attach->sequence)); 2407 memcpy(&(attach->sequence), list->items[x]->data, sizeof(attach->sequence));
2275 LE32_CPU(attach->sequence); 2408 LE32_CPU(attach->sequence);
2276 DEBUG_EMAIL(("%i\n", attach->sequence)); 2409 DEBUG_EMAIL(("%i\n", attach->sequence));
2277 break; 2410 break;
2278 case 0x3A00: // PR_ACCOUNT 2411 case 0x3A00: // PR_ACCOUNT
2279 DEBUG_EMAIL(("Contact's Account name - ")); 2412 DEBUG_EMAIL(("Contact's Account name - "));
2280 MALLOC_CONTACT(item); 2413 MALLOC_CONTACT(item);
2281 LIST_COPY(item->contact->account_name, (char*)); 2414 LIST_COPY(item->contact->account_name, (char*));
2282 DEBUG_EMAIL(("%s\n", item->contact->account_name)); 2415 DEBUG_EMAIL(("%s\n", item->contact->account_name));
2283 break; 2416 break;
2284 case 0x3A01: // PR_ALTERNATE_RECIPIENT 2417 case 0x3A01: // PR_ALTERNATE_RECIPIENT
2285 DEBUG_EMAIL(("Contact Alternate Recipient - NOT PROCESSED\n")); 2418 DEBUG_EMAIL(("Contact Alternate Recipient - NOT PROCESSED\n"));
2286 break; 2419 break;
2287 case 0x3A02: // PR_CALLBACK_TELEPHONE_NUMBER 2420 case 0x3A02: // PR_CALLBACK_TELEPHONE_NUMBER
2288 DEBUG_EMAIL(("Callback telephone number - ")); 2421 DEBUG_EMAIL(("Callback telephone number - "));
2289 MALLOC_CONTACT(item); 2422 MALLOC_CONTACT(item);
2290 LIST_COPY(item->contact->callback_phone, (char*)); 2423 LIST_COPY(item->contact->callback_phone, (char*));
2291 DEBUG_EMAIL(("%s\n", item->contact->callback_phone)); 2424 DEBUG_EMAIL(("%s\n", item->contact->callback_phone));
2292 break; 2425 break;
2293 case 0x3A03: // PR_CONVERSION_PROHIBITED 2426 case 0x3A03: // PR_CONVERSION_PROHIBITED
2294 DEBUG_EMAIL(("Message Conversion Prohibited - ")); 2427 DEBUG_EMAIL(("Message Conversion Prohibited - "));
2295 MALLOC_EMAIL(item); 2428 MALLOC_EMAIL(item);
2296 if (*(int16_t*)list->items[x]->data != 0) { 2429 if (*(int16_t*)list->items[x]->data != 0) {
2297 DEBUG_EMAIL(("True\n")); 2430 DEBUG_EMAIL(("True\n"));
2298 item->email->conversion_prohib = 1; 2431 item->email->conversion_prohib = 1;
2299 } else { 2432 } else {
2300 DEBUG_EMAIL(("False\n")); 2433 DEBUG_EMAIL(("False\n"));
2301 item->email->conversion_prohib = 0; 2434 item->email->conversion_prohib = 0;
2302 } 2435 }
2303 break; 2436 break;
2304 case 0x3A05: // PR_GENERATION suffix 2437 case 0x3A05: // PR_GENERATION suffix
2305 DEBUG_EMAIL(("Contacts Suffix - ")); 2438 DEBUG_EMAIL(("Contacts Suffix - "));
2306 MALLOC_CONTACT(item); 2439 MALLOC_CONTACT(item);
2307 LIST_COPY(item->contact->suffix, (char*)); 2440 LIST_COPY(item->contact->suffix, (char*));
2308 DEBUG_EMAIL(("%s\n", item->contact->suffix)); 2441 DEBUG_EMAIL(("%s\n", item->contact->suffix));
2309 break; 2442 break;
2310 case 0x3A06: // PR_GIVEN_NAME Contact's first name 2443 case 0x3A06: // PR_GIVEN_NAME Contact's first name
2311 DEBUG_EMAIL(("Contacts First Name - ")); 2444 DEBUG_EMAIL(("Contacts First Name - "));
2312 MALLOC_CONTACT(item); 2445 MALLOC_CONTACT(item);
2313 LIST_COPY(item->contact->first_name, (char*)); 2446 LIST_COPY(item->contact->first_name, (char*));
2314 DEBUG_EMAIL(("%s\n", item->contact->first_name)); 2447 DEBUG_EMAIL(("%s\n", item->contact->first_name));
2315 break; 2448 break;
2316 case 0x3A07: // PR_GOVERNMENT_ID_NUMBER 2449 case 0x3A07: // PR_GOVERNMENT_ID_NUMBER
2317 DEBUG_EMAIL(("Contacts Government ID Number - ")); 2450 DEBUG_EMAIL(("Contacts Government ID Number - "));
2318 MALLOC_CONTACT(item); 2451 MALLOC_CONTACT(item);
2319 LIST_COPY(item->contact->gov_id, (char*)); 2452 LIST_COPY(item->contact->gov_id, (char*));
2320 DEBUG_EMAIL(("%s\n", item->contact->gov_id)); 2453 DEBUG_EMAIL(("%s\n", item->contact->gov_id));
2321 break; 2454 break;
2322 case 0x3A08: // PR_BUSINESS_TELEPHONE_NUMBER 2455 case 0x3A08: // PR_BUSINESS_TELEPHONE_NUMBER
2323 DEBUG_EMAIL(("Business Telephone Number - ")); 2456 DEBUG_EMAIL(("Business Telephone Number - "));
2324 MALLOC_CONTACT(item); 2457 MALLOC_CONTACT(item);
2325 LIST_COPY(item->contact->business_phone, (char*)); 2458 LIST_COPY(item->contact->business_phone, (char*));
2326 DEBUG_EMAIL(("%s\n", item->contact->business_phone)); 2459 DEBUG_EMAIL(("%s\n", item->contact->business_phone));
2327 break; 2460 break;
2328 case 0x3A09: // PR_HOME_TELEPHONE_NUMBER 2461 case 0x3A09: // PR_HOME_TELEPHONE_NUMBER
2329 DEBUG_EMAIL(("Home Telephone Number - ")); 2462 DEBUG_EMAIL(("Home Telephone Number - "));
2330 MALLOC_CONTACT(item); 2463 MALLOC_CONTACT(item);
2331 LIST_COPY(item->contact->home_phone, (char*)); 2464 LIST_COPY(item->contact->home_phone, (char*));
2332 DEBUG_EMAIL(("%s\n", item->contact->home_phone)); 2465 DEBUG_EMAIL(("%s\n", item->contact->home_phone));
2333 break; 2466 break;
2334 case 0x3A0A: // PR_INITIALS Contact's Initials 2467 case 0x3A0A: // PR_INITIALS Contact's Initials
2335 DEBUG_EMAIL(("Contacts Initials - ")); 2468 DEBUG_EMAIL(("Contacts Initials - "));
2336 MALLOC_CONTACT(item); 2469 MALLOC_CONTACT(item);
2337 LIST_COPY(item->contact->initials, (char*)); 2470 LIST_COPY(item->contact->initials, (char*));
2338 DEBUG_EMAIL(("%s\n", item->contact->initials)); 2471 DEBUG_EMAIL(("%s\n", item->contact->initials));
2339 break; 2472 break;
2340 case 0x3A0B: // PR_KEYWORD 2473 case 0x3A0B: // PR_KEYWORD
2341 DEBUG_EMAIL(("Keyword - ")); 2474 DEBUG_EMAIL(("Keyword - "));
2342 MALLOC_CONTACT(item); 2475 MALLOC_CONTACT(item);
2343 LIST_COPY(item->contact->keyword, (char*)); 2476 LIST_COPY(item->contact->keyword, (char*));
2344 DEBUG_EMAIL(("%s\n", item->contact->keyword)); 2477 DEBUG_EMAIL(("%s\n", item->contact->keyword));
2345 break; 2478 break;
2346 case 0x3A0C: // PR_LANGUAGE 2479 case 0x3A0C: // PR_LANGUAGE
2347 DEBUG_EMAIL(("Contact's Language - ")); 2480 DEBUG_EMAIL(("Contact's Language - "));
2348 MALLOC_CONTACT(item); 2481 MALLOC_CONTACT(item);
2349 LIST_COPY(item->contact->language, (char*)); 2482 LIST_COPY(item->contact->language, (char*));
2350 DEBUG_EMAIL(("%s\n", item->contact->language)); 2483 DEBUG_EMAIL(("%s\n", item->contact->language));
2351 break; 2484 break;
2352 case 0x3A0D: // PR_LOCATION 2485 case 0x3A0D: // PR_LOCATION
2353 DEBUG_EMAIL(("Contact's Location - ")); 2486 DEBUG_EMAIL(("Contact's Location - "));
2354 MALLOC_CONTACT(item); 2487 MALLOC_CONTACT(item);
2355 LIST_COPY(item->contact->location, (char*)); 2488 LIST_COPY(item->contact->location, (char*));
2356 DEBUG_EMAIL(("%s\n", item->contact->location)); 2489 DEBUG_EMAIL(("%s\n", item->contact->location));
2357 break; 2490 break;
2358 case 0x3A0E: // PR_MAIL_PERMISSION - Can the recipient receive and send email 2491 case 0x3A0E: // PR_MAIL_PERMISSION - Can the recipient receive and send email
2359 DEBUG_EMAIL(("Mail Permission - ")); 2492 DEBUG_EMAIL(("Mail Permission - "));
2360 MALLOC_CONTACT(item); 2493 MALLOC_CONTACT(item);
2361 if (*(int16_t*)list->items[x]->data != 0) { 2494 if (*(int16_t*)list->items[x]->data != 0) {
2362 DEBUG_EMAIL(("True\n")); 2495 DEBUG_EMAIL(("True\n"));
2363 item->contact->mail_permission = 1; 2496 item->contact->mail_permission = 1;
2364 } else { 2497 } else {
2365 DEBUG_EMAIL(("False\n")); 2498 DEBUG_EMAIL(("False\n"));
2366 item->contact->mail_permission = 0; 2499 item->contact->mail_permission = 0;
2367 } 2500 }
2368 break; 2501 break;
2369 case 0x3A0F: // PR_MHS_COMMON_NAME 2502 case 0x3A0F: // PR_MHS_COMMON_NAME
2370 DEBUG_EMAIL(("MHS Common Name - ")); 2503 DEBUG_EMAIL(("MHS Common Name - "));
2371 MALLOC_EMAIL(item); 2504 MALLOC_EMAIL(item);
2372 LIST_COPY(item->email->common_name, (char*)); 2505 LIST_COPY(item->email->common_name, (char*));
2373 DEBUG_EMAIL(("%s\n", item->email->common_name)); 2506 DEBUG_EMAIL(("%s\n", item->email->common_name));
2374 break; 2507 break;
2375 case 0x3A10: // PR_ORGANIZATIONAL_ID_NUMBER 2508 case 0x3A10: // PR_ORGANIZATIONAL_ID_NUMBER
2376 DEBUG_EMAIL(("Organizational ID # - ")); 2509 DEBUG_EMAIL(("Organizational ID # - "));
2377 MALLOC_CONTACT(item); 2510 MALLOC_CONTACT(item);
2378 LIST_COPY(item->contact->org_id, (char*)); 2511 LIST_COPY(item->contact->org_id, (char*));
2379 DEBUG_EMAIL(("%s\n", item->contact->org_id)); 2512 DEBUG_EMAIL(("%s\n", item->contact->org_id));
2380 break; 2513 break;
2381 case 0x3A11: // PR_SURNAME Contact's Surname 2514 case 0x3A11: // PR_SURNAME Contact's Surname
2382 DEBUG_EMAIL(("Contacts Surname - ")); 2515 DEBUG_EMAIL(("Contacts Surname - "));
2383 MALLOC_CONTACT(item); 2516 MALLOC_CONTACT(item);
2384 LIST_COPY(item->contact->surname, (char*)); 2517 LIST_COPY(item->contact->surname, (char*));
2385 DEBUG_EMAIL(("%s\n", item->contact->surname)); 2518 DEBUG_EMAIL(("%s\n", item->contact->surname));
2386 break; 2519 break;
2387 case 0x3A12: // PR_ORIGINAL_ENTRY_ID 2520 case 0x3A12: // PR_ORIGINAL_ENTRY_ID
2388 DEBUG_EMAIL(("Original Entry ID - NOT PROCESSED\n")); 2521 DEBUG_EMAIL(("Original Entry ID - NOT PROCESSED\n"));
2389 break; 2522 break;
2390 case 0x3A13: // PR_ORIGINAL_DISPLAY_NAME 2523 case 0x3A13: // PR_ORIGINAL_DISPLAY_NAME
2391 DEBUG_EMAIL(("Original Display Name - NOT PROCESSED\n")); 2524 DEBUG_EMAIL(("Original Display Name - NOT PROCESSED\n"));
2392 break; 2525 break;
2393 case 0x3A14: // PR_ORIGINAL_SEARCH_KEY 2526 case 0x3A14: // PR_ORIGINAL_SEARCH_KEY
2394 DEBUG_EMAIL(("Original Search Key - NOT PROCESSED\n")); 2527 DEBUG_EMAIL(("Original Search Key - NOT PROCESSED\n"));
2395 break; 2528 break;
2396 case 0x3A15: // PR_POSTAL_ADDRESS 2529 case 0x3A15: // PR_POSTAL_ADDRESS
2397 DEBUG_EMAIL(("Default Postal Address - ")); 2530 DEBUG_EMAIL(("Default Postal Address - "));
2398 MALLOC_CONTACT(item); 2531 MALLOC_CONTACT(item);
2399 LIST_COPY(item->contact->def_postal_address, (char*)); 2532 LIST_COPY(item->contact->def_postal_address, (char*));
2400 DEBUG_EMAIL(("%s\n", item->contact->def_postal_address)); 2533 DEBUG_EMAIL(("%s\n", item->contact->def_postal_address));
2401 break; 2534 break;
2402 case 0x3A16: // PR_COMPANY_NAME 2535 case 0x3A16: // PR_COMPANY_NAME
2403 DEBUG_EMAIL(("Company Name - ")); 2536 DEBUG_EMAIL(("Company Name - "));
2404 MALLOC_CONTACT(item); 2537 MALLOC_CONTACT(item);
2405 LIST_COPY(item->contact->company_name, (char*)); 2538 LIST_COPY(item->contact->company_name, (char*));
2406 DEBUG_EMAIL(("%s\n", item->contact->company_name)); 2539 DEBUG_EMAIL(("%s\n", item->contact->company_name));
2407 break; 2540 break;
2408 case 0x3A17: // PR_TITLE - Job Title 2541 case 0x3A17: // PR_TITLE - Job Title
2409 DEBUG_EMAIL(("Job Title - ")); 2542 DEBUG_EMAIL(("Job Title - "));
2410 MALLOC_CONTACT(item); 2543 MALLOC_CONTACT(item);
2411 LIST_COPY(item->contact->job_title, (char*)); 2544 LIST_COPY(item->contact->job_title, (char*));
2412 DEBUG_EMAIL(("%s\n", item->contact->job_title)); 2545 DEBUG_EMAIL(("%s\n", item->contact->job_title));
2413 break; 2546 break;
2414 case 0x3A18: // PR_DEPARTMENT_NAME 2547 case 0x3A18: // PR_DEPARTMENT_NAME
2415 DEBUG_EMAIL(("Department Name - ")); 2548 DEBUG_EMAIL(("Department Name - "));
2416 MALLOC_CONTACT(item); 2549 MALLOC_CONTACT(item);
2417 LIST_COPY(item->contact->department, (char*)); 2550 LIST_COPY(item->contact->department, (char*));
2418 DEBUG_EMAIL(("%s\n", item->contact->department)); 2551 DEBUG_EMAIL(("%s\n", item->contact->department));
2419 break; 2552 break;
2420 case 0x3A19: // PR_OFFICE_LOCATION 2553 case 0x3A19: // PR_OFFICE_LOCATION
2421 DEBUG_EMAIL(("Office Location - ")); 2554 DEBUG_EMAIL(("Office Location - "));
2422 MALLOC_CONTACT(item); 2555 MALLOC_CONTACT(item);
2423 LIST_COPY(item->contact->office_loc, (char*)); 2556 LIST_COPY(item->contact->office_loc, (char*));
2424 DEBUG_EMAIL(("%s\n", item->contact->office_loc)); 2557 DEBUG_EMAIL(("%s\n", item->contact->office_loc));
2425 break; 2558 break;
2426 case 0x3A1A: // PR_PRIMARY_TELEPHONE_NUMBER 2559 case 0x3A1A: // PR_PRIMARY_TELEPHONE_NUMBER
2427 DEBUG_EMAIL(("Primary Telephone - ")); 2560 DEBUG_EMAIL(("Primary Telephone - "));
2428 MALLOC_CONTACT(item); 2561 MALLOC_CONTACT(item);
2429 LIST_COPY(item->contact->primary_phone, (char*)); 2562 LIST_COPY(item->contact->primary_phone, (char*));
2430 DEBUG_EMAIL(("%s\n", item->contact->primary_phone)); 2563 DEBUG_EMAIL(("%s\n", item->contact->primary_phone));
2431 break; 2564 break;
2432 case 0x3A1B: // PR_BUSINESS2_TELEPHONE_NUMBER 2565 case 0x3A1B: // PR_BUSINESS2_TELEPHONE_NUMBER
2433 DEBUG_EMAIL(("Business Phone Number 2 - ")); 2566 DEBUG_EMAIL(("Business Phone Number 2 - "));
2434 MALLOC_CONTACT(item); 2567 MALLOC_CONTACT(item);
2435 LIST_COPY(item->contact->business_phone2, (char*)); 2568 LIST_COPY(item->contact->business_phone2, (char*));
2436 DEBUG_EMAIL(("%s\n", item->contact->business_phone2)); 2569 DEBUG_EMAIL(("%s\n", item->contact->business_phone2));
2437 break; 2570 break;
2438 case 0x3A1C: // PR_MOBILE_TELEPHONE_NUMBER 2571 case 0x3A1C: // PR_MOBILE_TELEPHONE_NUMBER
2439 DEBUG_EMAIL(("Mobile Phone Number - ")); 2572 DEBUG_EMAIL(("Mobile Phone Number - "));
2440 MALLOC_CONTACT(item); 2573 MALLOC_CONTACT(item);
2441 LIST_COPY(item->contact->mobile_phone, (char*)); 2574 LIST_COPY(item->contact->mobile_phone, (char*));
2442 DEBUG_EMAIL(("%s\n", item->contact->mobile_phone)); 2575 DEBUG_EMAIL(("%s\n", item->contact->mobile_phone));
2443 break; 2576 break;
2444 case 0x3A1D: // PR_RADIO_TELEPHONE_NUMBER 2577 case 0x3A1D: // PR_RADIO_TELEPHONE_NUMBER
2445 DEBUG_EMAIL(("Radio Phone Number - ")); 2578 DEBUG_EMAIL(("Radio Phone Number - "));
2446 MALLOC_CONTACT(item); 2579 MALLOC_CONTACT(item);
2447 LIST_COPY(item->contact->radio_phone, (char*)); 2580 LIST_COPY(item->contact->radio_phone, (char*));
2448 DEBUG_EMAIL(("%s\n", item->contact->radio_phone)); 2581 DEBUG_EMAIL(("%s\n", item->contact->radio_phone));
2449 break; 2582 break;
2450 case 0x3A1E: // PR_CAR_TELEPHONE_NUMBER 2583 case 0x3A1E: // PR_CAR_TELEPHONE_NUMBER
2451 DEBUG_EMAIL(("Car Phone Number - ")); 2584 DEBUG_EMAIL(("Car Phone Number - "));
2452 MALLOC_CONTACT(item); 2585 MALLOC_CONTACT(item);
2453 LIST_COPY(item->contact->car_phone, (char*)); 2586 LIST_COPY(item->contact->car_phone, (char*));
2454 DEBUG_EMAIL(("%s\n", item->contact->car_phone)); 2587 DEBUG_EMAIL(("%s\n", item->contact->car_phone));
2455 break; 2588 break;
2456 case 0x3A1F: // PR_OTHER_TELEPHONE_NUMBER 2589 case 0x3A1F: // PR_OTHER_TELEPHONE_NUMBER
2457 DEBUG_EMAIL(("Other Phone Number - ")); 2590 DEBUG_EMAIL(("Other Phone Number - "));
2458 MALLOC_CONTACT(item); 2591 MALLOC_CONTACT(item);
2459 LIST_COPY(item->contact->other_phone, (char*)); 2592 LIST_COPY(item->contact->other_phone, (char*));
2460 DEBUG_EMAIL(("%s\n", item->contact->other_phone)); 2593 DEBUG_EMAIL(("%s\n", item->contact->other_phone));
2461 break; 2594 break;
2462 case 0x3A20: // PR_TRANSMITTABLE_DISPLAY_NAME 2595 case 0x3A20: // PR_TRANSMITTABLE_DISPLAY_NAME
2463 DEBUG_EMAIL(("Transmittable Display Name - ")); 2596 DEBUG_EMAIL(("Transmittable Display Name - "));
2464 MALLOC_CONTACT(item); 2597 MALLOC_CONTACT(item);
2465 LIST_COPY(item->contact->transmittable_display_name, (char*)); 2598 LIST_COPY(item->contact->transmittable_display_name, (char*));
2466 DEBUG_EMAIL(("%s\n", item->contact->transmittable_display_name)); 2599 DEBUG_EMAIL(("%s\n", item->contact->transmittable_display_name));
2467 break; 2600 break;
2468 case 0x3A21: // PR_PAGER_TELEPHONE_NUMBER 2601 case 0x3A21: // PR_PAGER_TELEPHONE_NUMBER
2469 DEBUG_EMAIL(("Pager Phone Number - ")); 2602 DEBUG_EMAIL(("Pager Phone Number - "));
2470 MALLOC_CONTACT(item); 2603 MALLOC_CONTACT(item);
2471 LIST_COPY(item->contact->pager_phone, (char*)); 2604 LIST_COPY(item->contact->pager_phone, (char*));
2472 DEBUG_EMAIL(("%s\n", item->contact->pager_phone)); 2605 DEBUG_EMAIL(("%s\n", item->contact->pager_phone));
2473 break; 2606 break;
2474 case 0x3A22: // PR_USER_CERTIFICATE 2607 case 0x3A22: // PR_USER_CERTIFICATE
2475 DEBUG_EMAIL(("User Certificate - NOT PROCESSED")); 2608 DEBUG_EMAIL(("User Certificate - NOT PROCESSED"));
2476 break; 2609 break;
2477 case 0x3A23: // PR_PRIMARY_FAX_NUMBER 2610 case 0x3A23: // PR_PRIMARY_FAX_NUMBER
2478 DEBUG_EMAIL(("Primary Fax Number - ")); 2611 DEBUG_EMAIL(("Primary Fax Number - "));
2479 MALLOC_CONTACT(item); 2612 MALLOC_CONTACT(item);
2480 LIST_COPY(item->contact->primary_fax, (char*)); 2613 LIST_COPY(item->contact->primary_fax, (char*));
2481 DEBUG_EMAIL(("%s\n", item->contact->primary_fax)); 2614 DEBUG_EMAIL(("%s\n", item->contact->primary_fax));
2482 break; 2615 break;
2483 case 0x3A24: // PR_BUSINESS_FAX_NUMBER 2616 case 0x3A24: // PR_BUSINESS_FAX_NUMBER
2484 DEBUG_EMAIL(("Business Fax Number - ")); 2617 DEBUG_EMAIL(("Business Fax Number - "));
2485 MALLOC_CONTACT(item); 2618 MALLOC_CONTACT(item);
2486 LIST_COPY(item->contact->business_fax, (char*)); 2619 LIST_COPY(item->contact->business_fax, (char*));
2487 DEBUG_EMAIL(("%s\n", item->contact->business_fax)); 2620 DEBUG_EMAIL(("%s\n", item->contact->business_fax));
2488 break; 2621 break;
2489 case 0x3A25: // PR_HOME_FAX_NUMBER 2622 case 0x3A25: // PR_HOME_FAX_NUMBER
2490 DEBUG_EMAIL(("Home Fax Number - ")); 2623 DEBUG_EMAIL(("Home Fax Number - "));
2491 MALLOC_CONTACT(item); 2624 MALLOC_CONTACT(item);
2492 LIST_COPY(item->contact->home_fax, (char*)); 2625 LIST_COPY(item->contact->home_fax, (char*));
2493 DEBUG_EMAIL(("%s\n", item->contact->home_fax)); 2626 DEBUG_EMAIL(("%s\n", item->contact->home_fax));
2494 break; 2627 break;
2495 case 0x3A26: // PR_BUSINESS_ADDRESS_COUNTRY 2628 case 0x3A26: // PR_BUSINESS_ADDRESS_COUNTRY
2496 DEBUG_EMAIL(("Business Address Country - ")); 2629 DEBUG_EMAIL(("Business Address Country - "));
2497 MALLOC_CONTACT(item); 2630 MALLOC_CONTACT(item);
2498 LIST_COPY(item->contact->business_country, (char*)); 2631 LIST_COPY(item->contact->business_country, (char*));
2499 DEBUG_EMAIL(("%s\n", item->contact->business_country)); 2632 DEBUG_EMAIL(("%s\n", item->contact->business_country));
2500 break; 2633 break;
2501 case 0x3A27: // PR_BUSINESS_ADDRESS_CITY 2634 case 0x3A27: // PR_BUSINESS_ADDRESS_CITY
2502 DEBUG_EMAIL(("Business Address City - ")); 2635 DEBUG_EMAIL(("Business Address City - "));
2503 MALLOC_CONTACT(item); 2636 MALLOC_CONTACT(item);
2504 LIST_COPY(item->contact->business_city, (char*)); 2637 LIST_COPY(item->contact->business_city, (char*));
2505 DEBUG_EMAIL(("%s\n", item->contact->business_city)); 2638 DEBUG_EMAIL(("%s\n", item->contact->business_city));
2506 break; 2639 break;
2507 case 0x3A28: // PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE 2640 case 0x3A28: // PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE
2508 DEBUG_EMAIL(("Business Address State - ")); 2641 DEBUG_EMAIL(("Business Address State - "));
2509 MALLOC_CONTACT(item); 2642 MALLOC_CONTACT(item);
2510 LIST_COPY(item->contact->business_state, (char*)); 2643 LIST_COPY(item->contact->business_state, (char*));
2511 DEBUG_EMAIL(("%s\n", item->contact->business_state)); 2644 DEBUG_EMAIL(("%s\n", item->contact->business_state));
2512 break; 2645 break;
2513 case 0x3A29: // PR_BUSINESS_ADDRESS_STREET 2646 case 0x3A29: // PR_BUSINESS_ADDRESS_STREET
2514 DEBUG_EMAIL(("Business Address Street - ")); 2647 DEBUG_EMAIL(("Business Address Street - "));
2515 MALLOC_CONTACT(item); 2648 MALLOC_CONTACT(item);
2516 LIST_COPY(item->contact->business_street, (char*)); 2649 LIST_COPY(item->contact->business_street, (char*));
2517 DEBUG_EMAIL(("%s\n", item->contact->business_street)); 2650 DEBUG_EMAIL(("%s\n", item->contact->business_street));
2518 break; 2651 break;
2519 case 0x3A2A: // PR_BUSINESS_POSTAL_CODE 2652 case 0x3A2A: // PR_BUSINESS_POSTAL_CODE
2520 DEBUG_EMAIL(("Business Postal Code - ")); 2653 DEBUG_EMAIL(("Business Postal Code - "));
2521 MALLOC_CONTACT(item); 2654 MALLOC_CONTACT(item);
2522 LIST_COPY(item->contact->business_postal_code, (char*)); 2655 LIST_COPY(item->contact->business_postal_code, (char*));
2523 DEBUG_EMAIL(("%s\n", item->contact->business_postal_code)); 2656 DEBUG_EMAIL(("%s\n", item->contact->business_postal_code));
2524 break; 2657 break;
2525 case 0x3A2B: // PR_BUSINESS_PO_BOX 2658 case 0x3A2B: // PR_BUSINESS_PO_BOX
2526 DEBUG_EMAIL(("Business PO Box - ")); 2659 DEBUG_EMAIL(("Business PO Box - "));
2527 MALLOC_CONTACT(item); 2660 MALLOC_CONTACT(item);
2528 LIST_COPY(item->contact->business_po_box, (char*)); 2661 LIST_COPY(item->contact->business_po_box, (char*));
2529 DEBUG_EMAIL(("%s\n", item->contact->business_po_box)); 2662 DEBUG_EMAIL(("%s\n", item->contact->business_po_box));
2530 break; 2663 break;
2531 case 0x3A2C: // PR_TELEX_NUMBER 2664 case 0x3A2C: // PR_TELEX_NUMBER
2532 DEBUG_EMAIL(("Telex Number - ")); 2665 DEBUG_EMAIL(("Telex Number - "));
2533 MALLOC_CONTACT(item); 2666 MALLOC_CONTACT(item);
2534 LIST_COPY(item->contact->telex, (char*)); 2667 LIST_COPY(item->contact->telex, (char*));
2535 DEBUG_EMAIL(("%s\n", item->contact->telex)); 2668 DEBUG_EMAIL(("%s\n", item->contact->telex));
2536 break; 2669 break;
2537 case 0x3A2D: // PR_ISDN_NUMBER 2670 case 0x3A2D: // PR_ISDN_NUMBER
2538 DEBUG_EMAIL(("ISDN Number - ")); 2671 DEBUG_EMAIL(("ISDN Number - "));
2539 MALLOC_CONTACT(item); 2672 MALLOC_CONTACT(item);
2540 LIST_COPY(item->contact->isdn_phone, (char*)); 2673 LIST_COPY(item->contact->isdn_phone, (char*));
2541 DEBUG_EMAIL(("%s\n", item->contact->isdn_phone)); 2674 DEBUG_EMAIL(("%s\n", item->contact->isdn_phone));
2542 break; 2675 break;
2543 case 0x3A2E: // PR_ASSISTANT_TELEPHONE_NUMBER 2676 case 0x3A2E: // PR_ASSISTANT_TELEPHONE_NUMBER
2544 DEBUG_EMAIL(("Assistant Phone Number - ")); 2677 DEBUG_EMAIL(("Assistant Phone Number - "));
2545 MALLOC_CONTACT(item); 2678 MALLOC_CONTACT(item);
2546 LIST_COPY(item->contact->assistant_phone, (char*)); 2679 LIST_COPY(item->contact->assistant_phone, (char*));
2547 DEBUG_EMAIL(("%s\n", item->contact->assistant_phone)); 2680 DEBUG_EMAIL(("%s\n", item->contact->assistant_phone));
2548 break; 2681 break;
2549 case 0x3A2F: // PR_HOME2_TELEPHONE_NUMBER 2682 case 0x3A2F: // PR_HOME2_TELEPHONE_NUMBER
2550 DEBUG_EMAIL(("Home Phone 2 - ")); 2683 DEBUG_EMAIL(("Home Phone 2 - "));
2551 MALLOC_CONTACT(item); 2684 MALLOC_CONTACT(item);
2552 LIST_COPY(item->contact->home_phone2, (char*)); 2685 LIST_COPY(item->contact->home_phone2, (char*));
2553 DEBUG_EMAIL(("%s\n", item->contact->home_phone2)); 2686 DEBUG_EMAIL(("%s\n", item->contact->home_phone2));
2554 break; 2687 break;
2555 case 0x3A30: // PR_ASSISTANT 2688 case 0x3A30: // PR_ASSISTANT
2556 DEBUG_EMAIL(("Assistant's Name - ")); 2689 DEBUG_EMAIL(("Assistant's Name - "));
2557 MALLOC_CONTACT(item); 2690 MALLOC_CONTACT(item);
2558 LIST_COPY(item->contact->assistant_name, (char*)); 2691 LIST_COPY(item->contact->assistant_name, (char*));
2559 DEBUG_EMAIL(("%s\n", item->contact->assistant_name)); 2692 DEBUG_EMAIL(("%s\n", item->contact->assistant_name));
2560 break; 2693 break;
2561 case 0x3A40: // PR_SEND_RICH_INFO 2694 case 0x3A40: // PR_SEND_RICH_INFO
2562 DEBUG_EMAIL(("Can receive Rich Text - ")); 2695 DEBUG_EMAIL(("Can receive Rich Text - "));
2563 MALLOC_CONTACT(item); 2696 MALLOC_CONTACT(item);
2564 if(*(int16_t*)list->items[x]->data != 0) { 2697 if(*(int16_t*)list->items[x]->data != 0) {
2565 DEBUG_EMAIL(("True\n")); 2698 DEBUG_EMAIL(("True\n"));
2566 item->contact->rich_text = 1; 2699 item->contact->rich_text = 1;
2567 } else { 2700 } else {
2568 DEBUG_EMAIL(("False\n")); 2701 DEBUG_EMAIL(("False\n"));
2569 item->contact->rich_text = 0; 2702 item->contact->rich_text = 0;
2570 } 2703 }
2571 break; 2704 break;
2572 case 0x3A41: // PR_WEDDING_ANNIVERSARY 2705 case 0x3A41: // PR_WEDDING_ANNIVERSARY
2573 DEBUG_EMAIL(("Wedding Anniversary - ")); 2706 DEBUG_EMAIL(("Wedding Anniversary - "));
2574 MALLOC_CONTACT(item); 2707 MALLOC_CONTACT(item);
2575 LIST_COPY(item->contact->wedding_anniversary, (FILETIME*)); 2708 LIST_COPY(item->contact->wedding_anniversary, (FILETIME*));
2576 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->contact->wedding_anniversary))); 2709 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->contact->wedding_anniversary)));
2577 break; 2710 break;
2578 case 0x3A42: // PR_BIRTHDAY 2711 case 0x3A42: // PR_BIRTHDAY
2579 DEBUG_EMAIL(("Birthday - ")); 2712 DEBUG_EMAIL(("Birthday - "));
2580 MALLOC_CONTACT(item); 2713 MALLOC_CONTACT(item);
2581 LIST_COPY(item->contact->birthday, (FILETIME*)); 2714 LIST_COPY(item->contact->birthday, (FILETIME*));
2582 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->contact->birthday))); 2715 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->contact->birthday)));
2583 break; 2716 break;
2584 case 0x3A43: // PR_HOBBIES 2717 case 0x3A43: // PR_HOBBIES
2585 DEBUG_EMAIL(("Hobbies - ")); 2718 DEBUG_EMAIL(("Hobbies - "));
2586 MALLOC_CONTACT(item); 2719 MALLOC_CONTACT(item);
2587 LIST_COPY(item->contact->hobbies, (char*)); 2720 LIST_COPY(item->contact->hobbies, (char*));
2588 DEBUG_EMAIL(("%s\n", item->contact->hobbies)); 2721 DEBUG_EMAIL(("%s\n", item->contact->hobbies));
2589 break; 2722 break;
2590 case 0x3A44: // PR_MIDDLE_NAME 2723 case 0x3A44: // PR_MIDDLE_NAME
2591 DEBUG_EMAIL(("Middle Name - ")); 2724 DEBUG_EMAIL(("Middle Name - "));
2592 MALLOC_CONTACT(item); 2725 MALLOC_CONTACT(item);
2593 LIST_COPY(item->contact->middle_name, (char*)); 2726 LIST_COPY(item->contact->middle_name, (char*));
2594 DEBUG_EMAIL(("%s\n", item->contact->middle_name)); 2727 DEBUG_EMAIL(("%s\n", item->contact->middle_name));
2595 break; 2728 break;
2596 case 0x3A45: // PR_DISPLAY_NAME_PREFIX 2729 case 0x3A45: // PR_DISPLAY_NAME_PREFIX
2597 DEBUG_EMAIL(("Display Name Prefix (Title) - ")); 2730 DEBUG_EMAIL(("Display Name Prefix (Title) - "));
2598 MALLOC_CONTACT(item); 2731 MALLOC_CONTACT(item);
2599 LIST_COPY(item->contact->display_name_prefix, (char*)); 2732 LIST_COPY(item->contact->display_name_prefix, (char*));
2600 DEBUG_EMAIL(("%s\n", item->contact->display_name_prefix)); 2733 DEBUG_EMAIL(("%s\n", item->contact->display_name_prefix));
2601 break; 2734 break;
2602 case 0x3A46: // PR_PROFESSION 2735 case 0x3A46: // PR_PROFESSION
2603 DEBUG_EMAIL(("Profession - ")); 2736 DEBUG_EMAIL(("Profession - "));
2604 MALLOC_CONTACT(item); 2737 MALLOC_CONTACT(item);
2605 LIST_COPY(item->contact->profession, (char*)); 2738 LIST_COPY(item->contact->profession, (char*));
2606 DEBUG_EMAIL(("%s\n", item->contact->profession)); 2739 DEBUG_EMAIL(("%s\n", item->contact->profession));
2607 break; 2740 break;
2608 case 0x3A47: // PR_PREFERRED_BY_NAME 2741 case 0x3A47: // PR_PREFERRED_BY_NAME
2609 DEBUG_EMAIL(("Preferred By Name - ")); 2742 DEBUG_EMAIL(("Preferred By Name - "));
2610 MALLOC_CONTACT(item); 2743 MALLOC_CONTACT(item);
2611 LIST_COPY(item->contact->pref_name, (char*)); 2744 LIST_COPY(item->contact->pref_name, (char*));
2612 DEBUG_EMAIL(("%s\n", item->contact->pref_name)); 2745 DEBUG_EMAIL(("%s\n", item->contact->pref_name));
2613 break; 2746 break;
2614 case 0x3A48: // PR_SPOUSE_NAME 2747 case 0x3A48: // PR_SPOUSE_NAME
2615 DEBUG_EMAIL(("Spouse's Name - ")); 2748 DEBUG_EMAIL(("Spouse's Name - "));
2616 MALLOC_CONTACT(item); 2749 MALLOC_CONTACT(item);
2617 LIST_COPY(item->contact->spouse_name, (char*)); 2750 LIST_COPY(item->contact->spouse_name, (char*));
2618 DEBUG_EMAIL(("%s\n", item->contact->spouse_name)); 2751 DEBUG_EMAIL(("%s\n", item->contact->spouse_name));
2619 break; 2752 break;
2620 case 0x3A49: // PR_COMPUTER_NETWORK_NAME 2753 case 0x3A49: // PR_COMPUTER_NETWORK_NAME
2621 DEBUG_EMAIL(("Computer Network Name - ")); 2754 DEBUG_EMAIL(("Computer Network Name - "));
2622 MALLOC_CONTACT(item); 2755 MALLOC_CONTACT(item);
2623 LIST_COPY(item->contact->computer_name, (char*)); 2756 LIST_COPY(item->contact->computer_name, (char*));
2624 DEBUG_EMAIL(("%s\n", item->contact->computer_name)); 2757 DEBUG_EMAIL(("%s\n", item->contact->computer_name));
2625 break; 2758 break;
2626 case 0x3A4A: // PR_CUSTOMER_ID 2759 case 0x3A4A: // PR_CUSTOMER_ID
2627 DEBUG_EMAIL(("Customer ID - ")); 2760 DEBUG_EMAIL(("Customer ID - "));
2628 MALLOC_CONTACT(item); 2761 MALLOC_CONTACT(item);
2629 LIST_COPY(item->contact->customer_id, (char*)); 2762 LIST_COPY(item->contact->customer_id, (char*));
2630 DEBUG_EMAIL(("%s\n", item->contact->customer_id)); 2763 DEBUG_EMAIL(("%s\n", item->contact->customer_id));
2631 break; 2764 break;
2632 case 0x3A4B: // PR_TTYTDD_PHONE_NUMBER 2765 case 0x3A4B: // PR_TTYTDD_PHONE_NUMBER
2633 DEBUG_EMAIL(("TTY/TDD Phone - ")); 2766 DEBUG_EMAIL(("TTY/TDD Phone - "));
2634 MALLOC_CONTACT(item); 2767 MALLOC_CONTACT(item);
2635 LIST_COPY(item->contact->ttytdd_phone, (char*)); 2768 LIST_COPY(item->contact->ttytdd_phone, (char*));
2636 DEBUG_EMAIL(("%s\n", item->contact->ttytdd_phone)); 2769 DEBUG_EMAIL(("%s\n", item->contact->ttytdd_phone));
2637 break; 2770 break;
2638 case 0x3A4C: // PR_FTP_SITE 2771 case 0x3A4C: // PR_FTP_SITE
2639 DEBUG_EMAIL(("Ftp Site - ")); 2772 DEBUG_EMAIL(("Ftp Site - "));
2640 MALLOC_CONTACT(item); 2773 MALLOC_CONTACT(item);
2641 LIST_COPY(item->contact->ftp_site, (char*)); 2774 LIST_COPY(item->contact->ftp_site, (char*));
2642 DEBUG_EMAIL(("%s\n", item->contact->ftp_site)); 2775 DEBUG_EMAIL(("%s\n", item->contact->ftp_site));
2643 break; 2776 break;
2644 case 0x3A4D: // PR_GENDER 2777 case 0x3A4D: // PR_GENDER
2645 DEBUG_EMAIL(("Gender - ")); 2778 DEBUG_EMAIL(("Gender - "));
2646 MALLOC_CONTACT(item); 2779 MALLOC_CONTACT(item);
2647 memcpy(&item->contact->gender, list->items[x]->data, sizeof(int16_t)); 2780 memcpy(&item->contact->gender, list->items[x]->data, sizeof(int16_t));
2648 LE16_CPU(item->contact->gender); 2781 LE16_CPU(item->contact->gender);
2649 switch(item->contact->gender) { 2782 switch(item->contact->gender) {
2650 case 0: 2783 case 0:
2651 DEBUG_EMAIL(("Unspecified\n")); 2784 DEBUG_EMAIL(("Unspecified\n"));
2652 break; 2785 break;
2653 case 1: 2786 case 1:
2654 DEBUG_EMAIL(("Female\n")); 2787 DEBUG_EMAIL(("Female\n"));
2655 break; 2788 break;
2656 case 2: 2789 case 2:
2657 DEBUG_EMAIL(("Male\n")); 2790 DEBUG_EMAIL(("Male\n"));
2658 break; 2791 break;
2659 default: 2792 default:
2660 DEBUG_EMAIL(("Error processing\n")); 2793 DEBUG_EMAIL(("Error processing\n"));
2661 } 2794 }
2662 break; 2795 break;
2663 case 0x3A4E: // PR_MANAGER_NAME 2796 case 0x3A4E: // PR_MANAGER_NAME
2664 DEBUG_EMAIL(("Manager's Name - ")); 2797 DEBUG_EMAIL(("Manager's Name - "));
2665 MALLOC_CONTACT(item); 2798 MALLOC_CONTACT(item);
2666 LIST_COPY(item->contact->manager_name, (char*)); 2799 LIST_COPY(item->contact->manager_name, (char*));
2667 DEBUG_EMAIL(("%s\n", item->contact->manager_name)); 2800 DEBUG_EMAIL(("%s\n", item->contact->manager_name));
2668 break; 2801 break;
2669 case 0x3A4F: // PR_NICKNAME 2802 case 0x3A4F: // PR_NICKNAME
2670 DEBUG_EMAIL(("Nickname - ")); 2803 DEBUG_EMAIL(("Nickname - "));
2671 MALLOC_CONTACT(item); 2804 MALLOC_CONTACT(item);
2672 LIST_COPY(item->contact->nickname, (char*)); 2805 LIST_COPY(item->contact->nickname, (char*));
2673 DEBUG_EMAIL(("%s\n", item->contact->nickname)); 2806 DEBUG_EMAIL(("%s\n", item->contact->nickname));
2674 break; 2807 break;
2675 case 0x3A50: // PR_PERSONAL_HOME_PAGE 2808 case 0x3A50: // PR_PERSONAL_HOME_PAGE
2676 DEBUG_EMAIL(("Personal Home Page - ")); 2809 DEBUG_EMAIL(("Personal Home Page - "));
2677 MALLOC_CONTACT(item); 2810 MALLOC_CONTACT(item);
2678 LIST_COPY(item->contact->personal_homepage, (char*)); 2811 LIST_COPY(item->contact->personal_homepage, (char*));
2679 DEBUG_EMAIL(("%s\n", item->contact->personal_homepage)); 2812 DEBUG_EMAIL(("%s\n", item->contact->personal_homepage));
2680 break; 2813 break;
2681 case 0x3A51: // PR_BUSINESS_HOME_PAGE 2814 case 0x3A51: // PR_BUSINESS_HOME_PAGE
2682 DEBUG_EMAIL(("Business Home Page - ")); 2815 DEBUG_EMAIL(("Business Home Page - "));
2683 MALLOC_CONTACT(item); 2816 MALLOC_CONTACT(item);
2684 LIST_COPY(item->contact->business_homepage, (char*)); 2817 LIST_COPY(item->contact->business_homepage, (char*));
2685 DEBUG_EMAIL(("%s\n", item->contact->business_homepage)); 2818 DEBUG_EMAIL(("%s\n", item->contact->business_homepage));
2686 break; 2819 break;
2687 case 0x3A57: // PR_COMPANY_MAIN_PHONE_NUMBER 2820 case 0x3A57: // PR_COMPANY_MAIN_PHONE_NUMBER
2688 DEBUG_EMAIL(("Company Main Phone - ")); 2821 DEBUG_EMAIL(("Company Main Phone - "));
2689 MALLOC_CONTACT(item); 2822 MALLOC_CONTACT(item);
2690 LIST_COPY(item->contact->company_main_phone, (char*)); 2823 LIST_COPY(item->contact->company_main_phone, (char*));
2691 DEBUG_EMAIL(("%s\n", item->contact->company_main_phone)); 2824 DEBUG_EMAIL(("%s\n", item->contact->company_main_phone));
2692 break; 2825 break;
2693 case 0x3A58: // PR_CHILDRENS_NAMES 2826 case 0x3A58: // PR_CHILDRENS_NAMES
2694 DEBUG_EMAIL(("Children's Names - NOT PROCESSED\n")); 2827 DEBUG_EMAIL(("Children's Names - NOT PROCESSED\n"));
2695 break; 2828 break;
2696 case 0x3A59: // PR_HOME_ADDRESS_CITY 2829 case 0x3A59: // PR_HOME_ADDRESS_CITY
2697 DEBUG_EMAIL(("Home Address City - ")); 2830 DEBUG_EMAIL(("Home Address City - "));
2698 MALLOC_CONTACT(item); 2831 MALLOC_CONTACT(item);
2699 LIST_COPY(item->contact->home_city, (char*)); 2832 LIST_COPY(item->contact->home_city, (char*));
2700 DEBUG_EMAIL(("%s\n", item->contact->home_city)); 2833 DEBUG_EMAIL(("%s\n", item->contact->home_city));
2701 break; 2834 break;
2702 case 0x3A5A: // PR_HOME_ADDRESS_COUNTRY 2835 case 0x3A5A: // PR_HOME_ADDRESS_COUNTRY
2703 DEBUG_EMAIL(("Home Address Country - ")); 2836 DEBUG_EMAIL(("Home Address Country - "));
2704 MALLOC_CONTACT(item); 2837 MALLOC_CONTACT(item);
2705 LIST_COPY(item->contact->home_country, (char*)); 2838 LIST_COPY(item->contact->home_country, (char*));
2706 DEBUG_EMAIL(("%s\n", item->contact->home_country)); 2839 DEBUG_EMAIL(("%s\n", item->contact->home_country));
2707 break; 2840 break;
2708 case 0x3A5B: // PR_HOME_ADDRESS_POSTAL_CODE 2841 case 0x3A5B: // PR_HOME_ADDRESS_POSTAL_CODE
2709 DEBUG_EMAIL(("Home Address Postal Code - ")); 2842 DEBUG_EMAIL(("Home Address Postal Code - "));
2710 MALLOC_CONTACT(item); 2843 MALLOC_CONTACT(item);
2711 LIST_COPY(item->contact->home_postal_code, (char*)); 2844 LIST_COPY(item->contact->home_postal_code, (char*));
2712 DEBUG_EMAIL(("%s\n", item->contact->home_postal_code)); 2845 DEBUG_EMAIL(("%s\n", item->contact->home_postal_code));
2713 break; 2846 break;
2714 case 0x3A5C: // PR_HOME_ADDRESS_STATE_OR_PROVINCE 2847 case 0x3A5C: // PR_HOME_ADDRESS_STATE_OR_PROVINCE
2715 DEBUG_EMAIL(("Home Address State or Province - ")); 2848 DEBUG_EMAIL(("Home Address State or Province - "));
2716 MALLOC_CONTACT(item); 2849 MALLOC_CONTACT(item);
2717 LIST_COPY(item->contact->home_state, (char*)); 2850 LIST_COPY(item->contact->home_state, (char*));
2718 DEBUG_EMAIL(("%s\n", item->contact->home_state)); 2851 DEBUG_EMAIL(("%s\n", item->contact->home_state));
2719 break; 2852 break;
2720 case 0x3A5D: // PR_HOME_ADDRESS_STREET 2853 case 0x3A5D: // PR_HOME_ADDRESS_STREET
2721 DEBUG_EMAIL(("Home Address Street - ")); 2854 DEBUG_EMAIL(("Home Address Street - "));
2722 MALLOC_CONTACT(item); 2855 MALLOC_CONTACT(item);
2723 LIST_COPY(item->contact->home_street, (char*)); 2856 LIST_COPY(item->contact->home_street, (char*));
2724 DEBUG_EMAIL(("%s\n", item->contact->home_street)); 2857 DEBUG_EMAIL(("%s\n", item->contact->home_street));
2725 break; 2858 break;
2726 case 0x3A5E: // PR_HOME_ADDRESS_POST_OFFICE_BOX 2859 case 0x3A5E: // PR_HOME_ADDRESS_POST_OFFICE_BOX
2727 DEBUG_EMAIL(("Home Address Post Office Box - ")); 2860 DEBUG_EMAIL(("Home Address Post Office Box - "));
2728 MALLOC_CONTACT(item); 2861 MALLOC_CONTACT(item);
2729 LIST_COPY(item->contact->home_po_box, (char*)); 2862 LIST_COPY(item->contact->home_po_box, (char*));
2730 DEBUG_EMAIL(("%s\n", item->contact->home_po_box)); 2863 DEBUG_EMAIL(("%s\n", item->contact->home_po_box));
2731 break; 2864 break;
2732 case 0x3A5F: // PR_OTHER_ADDRESS_CITY 2865 case 0x3A5F: // PR_OTHER_ADDRESS_CITY
2733 DEBUG_EMAIL(("Other Address City - ")); 2866 DEBUG_EMAIL(("Other Address City - "));
2734 MALLOC_CONTACT(item); 2867 MALLOC_CONTACT(item);
2735 LIST_COPY(item->contact->other_city, (char*)); 2868 LIST_COPY(item->contact->other_city, (char*));
2736 DEBUG_EMAIL(("%s\n", item->contact->other_city)); 2869 DEBUG_EMAIL(("%s\n", item->contact->other_city));
2737 break; 2870 break;
2738 case 0x3A60: // PR_OTHER_ADDRESS_COUNTRY 2871 case 0x3A60: // PR_OTHER_ADDRESS_COUNTRY
2739 DEBUG_EMAIL(("Other Address Country - ")); 2872 DEBUG_EMAIL(("Other Address Country - "));
2740 MALLOC_CONTACT(item); 2873 MALLOC_CONTACT(item);
2741 LIST_COPY(item->contact->other_country, (char*)); 2874 LIST_COPY(item->contact->other_country, (char*));
2742 DEBUG_EMAIL(("%s\n", item->contact->other_country)); 2875 DEBUG_EMAIL(("%s\n", item->contact->other_country));
2743 break; 2876 break;
2744 case 0x3A61: // PR_OTHER_ADDRESS_POSTAL_CODE 2877 case 0x3A61: // PR_OTHER_ADDRESS_POSTAL_CODE
2745 DEBUG_EMAIL(("Other Address Postal Code - ")); 2878 DEBUG_EMAIL(("Other Address Postal Code - "));
2746 MALLOC_CONTACT(item); 2879 MALLOC_CONTACT(item);
2747 LIST_COPY(item->contact->other_postal_code, (char*)); 2880 LIST_COPY(item->contact->other_postal_code, (char*));
2748 DEBUG_EMAIL(("%s\n", item->contact->other_postal_code)); 2881 DEBUG_EMAIL(("%s\n", item->contact->other_postal_code));
2749 break; 2882 break;
2750 case 0x3A62: // PR_OTHER_ADDRESS_STATE_OR_PROVINCE 2883 case 0x3A62: // PR_OTHER_ADDRESS_STATE_OR_PROVINCE
2751 DEBUG_EMAIL(("Other Address State - ")); 2884 DEBUG_EMAIL(("Other Address State - "));
2752 MALLOC_CONTACT(item); 2885 MALLOC_CONTACT(item);
2753 LIST_COPY(item->contact->other_state, (char*)); 2886 LIST_COPY(item->contact->other_state, (char*));
2754 DEBUG_EMAIL(("%s\n", item->contact->other_state)); 2887 DEBUG_EMAIL(("%s\n", item->contact->other_state));
2755 break; 2888 break;
2756 case 0x3A63: // PR_OTHER_ADDRESS_STREET 2889 case 0x3A63: // PR_OTHER_ADDRESS_STREET
2757 DEBUG_EMAIL(("Other Address Street - ")); 2890 DEBUG_EMAIL(("Other Address Street - "));
2758 MALLOC_CONTACT(item); 2891 MALLOC_CONTACT(item);
2759 LIST_COPY(item->contact->other_street, (char*)); 2892 LIST_COPY(item->contact->other_street, (char*));
2760 DEBUG_EMAIL(("%s\n", item->contact->other_street)); 2893 DEBUG_EMAIL(("%s\n", item->contact->other_street));
2761 break; 2894 break;
2762 case 0x3A64: // PR_OTHER_ADDRESS_POST_OFFICE_BOX 2895 case 0x3A64: // PR_OTHER_ADDRESS_POST_OFFICE_BOX
2763 DEBUG_EMAIL(("Other Address Post Office box - ")); 2896 DEBUG_EMAIL(("Other Address Post Office box - "));
2764 MALLOC_CONTACT(item); 2897 MALLOC_CONTACT(item);
2765 LIST_COPY(item->contact->other_po_box, (char*)); 2898 LIST_COPY(item->contact->other_po_box, (char*));
2766 DEBUG_EMAIL(("%s\n", item->contact->other_po_box)); 2899 DEBUG_EMAIL(("%s\n", item->contact->other_po_box));
2767 break; 2900 break;
2768 case 0x65E3: // Entry ID? 2901 case 0x65E3: // Entry ID?
2769 DEBUG_EMAIL(("Entry ID - ")); 2902 DEBUG_EMAIL(("Entry ID - "));
2770 item->record_key = (char*) xmalloc(16+1); 2903 item->record_key = (char*) xmalloc(16+1);
2771 memcpy(item->record_key, &(list->items[x]->data[1]), 16); //skip first byte 2904 memcpy(item->record_key, &(list->items[x]->data[1]), 16); //skip first byte
2772 item->record_key[16]='\0'; 2905 item->record_key[16]='\0';
2773 item->record_key_size=16; 2906 item->record_key_size=16;
2774 DEBUG_EMAIL_HEXPRINT((char*)item->record_key, 16); 2907 DEBUG_EMAIL_HEXPRINT((char*)item->record_key, 16);
2775 break; 2908 break;
2776 case 0x67F2: // ID2 value of the attachments proper record 2909 case 0x67F2: // ID2 value of the attachments proper record
2777 DEBUG_EMAIL(("Attachment ID2 value - ")); 2910 DEBUG_EMAIL(("Attachment ID2 value - "));
2778 if (attach){ 2911 if (attach){
2779 MOVE_NEXT(attach); 2912 MOVE_NEXT(attach);
2780 memcpy(&(attach->id2_val), list->items[x]->data, sizeof(attach->id2_val)); 2913 memcpy(&(attach->id2_val), list->items[x]->data, sizeof(attach->id2_val));
2781 LE32_CPU(attach->id2_val); 2914 LE32_CPU(attach->id2_val);
2782 DEBUG_EMAIL(("%#x\n", attach->id2_val)); 2915 DEBUG_EMAIL(("%#x\n", attach->id2_val));
2783 } else { 2916 } else {
2784 DEBUG_EMAIL(("NOT AN ATTACHMENT: %#x\n", list->items[x]->id)); 2917 DEBUG_EMAIL(("NOT AN ATTACHMENT: %#x\n", list->items[x]->id));
2785 } 2918 }
2786 break; 2919 break;
2787 case 0x67FF: // Extra Property Identifier (Password CheckSum) 2920 case 0x67FF: // Extra Property Identifier (Password CheckSum)
2788 DEBUG_EMAIL(("Password checksum [0x67FF] - ")); 2921 DEBUG_EMAIL(("Password checksum [0x67FF] - "));
2789 MALLOC_MESSAGESTORE(item); 2922 MALLOC_MESSAGESTORE(item);
2790 memcpy(&(item->message_store->pwd_chksum), list->items[x]->data, 2923 memcpy(&(item->message_store->pwd_chksum), list->items[x]->data,
2791 sizeof(item->message_store->pwd_chksum)); 2924 sizeof(item->message_store->pwd_chksum));
2792 DEBUG_EMAIL(("%#x\n", item->message_store->pwd_chksum)); 2925 DEBUG_EMAIL(("%#x\n", item->message_store->pwd_chksum));
2793 break; 2926 break;
2794 case 0x6F02: // Secure HTML Body 2927 case 0x6F02: // Secure HTML Body
2795 DEBUG_EMAIL(("Secure HTML Body - ")); 2928 DEBUG_EMAIL(("Secure HTML Body - "));
2796 MALLOC_EMAIL(item); 2929 MALLOC_EMAIL(item);
2797 LIST_COPY(item->email->encrypted_htmlbody, (char*)); 2930 LIST_COPY(item->email->encrypted_htmlbody, (char*));
2798 item->email->encrypted_htmlbody_size = list->items[x]->size; 2931 item->email->encrypted_htmlbody_size = list->items[x]->size;
2799 DEBUG_EMAIL(("Not Printed\n")); 2932 DEBUG_EMAIL(("Not Printed\n"));
2800 break; 2933 break;
2801 case 0x6F04: // Secure Text Body 2934 case 0x6F04: // Secure Text Body
2802 DEBUG_EMAIL(("Secure Text Body - ")); 2935 DEBUG_EMAIL(("Secure Text Body - "));
2803 MALLOC_EMAIL(item); 2936 MALLOC_EMAIL(item);
2804 LIST_COPY(item->email->encrypted_body, (char*)); 2937 LIST_COPY(item->email->encrypted_body, (char*));
2805 item->email->encrypted_body_size = list->items[x]->size; 2938 item->email->encrypted_body_size = list->items[x]->size;
2806 DEBUG_EMAIL(("Not Printed\n")); 2939 DEBUG_EMAIL(("Not Printed\n"));
2807 break; 2940 break;
2808 case 0x7C07: // top of folders ENTRYID 2941 case 0x7C07: // top of folders ENTRYID
2809 DEBUG_EMAIL(("Top of folders RecID [0x7c07] - ")); 2942 DEBUG_EMAIL(("Top of folders RecID [0x7c07] - "));
2810 MALLOC_MESSAGESTORE(item); 2943 MALLOC_MESSAGESTORE(item);
2811 item->message_store->top_of_folder = (pst_entryid*) xmalloc(sizeof(pst_entryid)); 2944 item->message_store->top_of_folder = (pst_entryid*) xmalloc(sizeof(pst_entryid));
2812 memcpy(item->message_store->top_of_folder, list->items[x]->data, sizeof(pst_entryid)); 2945 memcpy(item->message_store->top_of_folder, list->items[x]->data, sizeof(pst_entryid));
2813 LE32_CPU(item->message_store->top_of_folder->u1); 2946 LE32_CPU(item->message_store->top_of_folder->u1);
2814 LE32_CPU(item->message_store->top_of_folder->id); 2947 LE32_CPU(item->message_store->top_of_folder->id);
2815 DEBUG_EMAIL_HEXPRINT((char*)item->message_store->top_of_folder->entryid, 16); 2948 DEBUG_EMAIL_HEXPRINT((char*)item->message_store->top_of_folder->entryid, 16);
2816 break; 2949 break;
2817 case 0x8005: // Contact's Fullname 2950 case 0x8005: // Contact's Fullname
2818 DEBUG_EMAIL(("Contact Fullname - ")); 2951 DEBUG_EMAIL(("Contact Fullname - "));
2819 MALLOC_CONTACT(item); 2952 MALLOC_CONTACT(item);
2820 LIST_COPY(item->contact->fullname, (char*)); 2953 LIST_COPY(item->contact->fullname, (char*));
2821 DEBUG_EMAIL(("%s\n", item->contact->fullname)); 2954 DEBUG_EMAIL(("%s\n", item->contact->fullname));
2822 break; 2955 break;
2823 case 0x801A: // Full Home Address 2956 case 0x801A: // Full Home Address
2824 DEBUG_EMAIL(("Home Address - ")); 2957 DEBUG_EMAIL(("Home Address - "));
2825 MALLOC_CONTACT(item); 2958 MALLOC_CONTACT(item);
2826 LIST_COPY(item->contact->home_address, (char*)); 2959 LIST_COPY(item->contact->home_address, (char*));
2827 DEBUG_EMAIL(("%s\n", item->contact->home_address)); 2960 DEBUG_EMAIL(("%s\n", item->contact->home_address));
2828 break; 2961 break;
2829 case 0x801B: // Full Business Address 2962 case 0x801B: // Full Business Address
2830 DEBUG_EMAIL(("Business Address - ")); 2963 DEBUG_EMAIL(("Business Address - "));
2831 MALLOC_CONTACT(item); 2964 MALLOC_CONTACT(item);
2832 LIST_COPY(item->contact->business_address, (char*)); 2965 LIST_COPY(item->contact->business_address, (char*));
2833 DEBUG_EMAIL(("%s\n", item->contact->business_address)); 2966 DEBUG_EMAIL(("%s\n", item->contact->business_address));
2834 break; 2967 break;
2835 case 0x801C: // Full Other Address 2968 case 0x801C: // Full Other Address
2836 DEBUG_EMAIL(("Other Address - ")); 2969 DEBUG_EMAIL(("Other Address - "));
2837 MALLOC_CONTACT(item); 2970 MALLOC_CONTACT(item);
2838 LIST_COPY(item->contact->other_address, (char*)); 2971 LIST_COPY(item->contact->other_address, (char*));
2839 DEBUG_EMAIL(("%s\n", item->contact->other_address)); 2972 DEBUG_EMAIL(("%s\n", item->contact->other_address));
2840 break; 2973 break;
2841 case 0x8082: // Email Address 1 Transport 2974 case 0x8082: // Email Address 1 Transport
2842 DEBUG_EMAIL(("Email Address 1 Transport - ")); 2975 DEBUG_EMAIL(("Email Address 1 Transport - "));
2843 MALLOC_CONTACT(item); 2976 MALLOC_CONTACT(item);
2844 LIST_COPY(item->contact->address1_transport, (char*)); 2977 LIST_COPY(item->contact->address1_transport, (char*));
2845 DEBUG_EMAIL(("|%s|\n", item->contact->address1_transport)); 2978 DEBUG_EMAIL(("|%s|\n", item->contact->address1_transport));
2846 break; 2979 break;
2847 case 0x8083: // Email Address 1 Address 2980 case 0x8083: // Email Address 1 Address
2848 DEBUG_EMAIL(("Email Address 1 Address - ")); 2981 DEBUG_EMAIL(("Email Address 1 Address - "));
2849 MALLOC_CONTACT(item); 2982 MALLOC_CONTACT(item);
2850 LIST_COPY(item->contact->address1, (char*)); 2983 LIST_COPY(item->contact->address1, (char*));
2851 DEBUG_EMAIL(("|%s|\n", item->contact->address1)); 2984 DEBUG_EMAIL(("|%s|\n", item->contact->address1));
2852 break; 2985 break;
2853 case 0x8084: // Email Address 1 Description 2986 case 0x8084: // Email Address 1 Description
2854 DEBUG_EMAIL(("Email Address 1 Description - ")); 2987 DEBUG_EMAIL(("Email Address 1 Description - "));
2855 MALLOC_CONTACT(item); 2988 MALLOC_CONTACT(item);
2856 LIST_COPY(item->contact->address1_desc, (char*)); 2989 LIST_COPY(item->contact->address1_desc, (char*));
2857 DEBUG_EMAIL(("|%s|\n", item->contact->address1_desc)); 2990 DEBUG_EMAIL(("|%s|\n", item->contact->address1_desc));
2858 break; 2991 break;
2859 case 0x8085: // Email Address 1 Record 2992 case 0x8085: // Email Address 1 Record
2860 DEBUG_EMAIL(("Email Address 1 Record - ")); 2993 DEBUG_EMAIL(("Email Address 1 Record - "));
2861 MALLOC_CONTACT(item); 2994 MALLOC_CONTACT(item);
2862 LIST_COPY(item->contact->address1a, (char*)); 2995 LIST_COPY(item->contact->address1a, (char*));
2863 DEBUG_EMAIL(("|%s|\n", item->contact->address1a)); 2996 DEBUG_EMAIL(("|%s|\n", item->contact->address1a));
2864 break; 2997 break;
2865 case 0x8092: // Email Address 2 Transport 2998 case 0x8092: // Email Address 2 Transport
2866 DEBUG_EMAIL(("Email Address 2 Transport - ")); 2999 DEBUG_EMAIL(("Email Address 2 Transport - "));
2867 MALLOC_CONTACT(item); 3000 MALLOC_CONTACT(item);
2868 LIST_COPY(item->contact->address2_transport, (char*)); 3001 LIST_COPY(item->contact->address2_transport, (char*));
2869 DEBUG_EMAIL(("|%s|\n", item->contact->address2_transport)); 3002 DEBUG_EMAIL(("|%s|\n", item->contact->address2_transport));
2870 break; 3003 break;
2871 case 0x8093: // Email Address 2 Address 3004 case 0x8093: // Email Address 2 Address
2872 DEBUG_EMAIL(("Email Address 2 Address - ")); 3005 DEBUG_EMAIL(("Email Address 2 Address - "));
2873 MALLOC_CONTACT(item); 3006 MALLOC_CONTACT(item);
2874 LIST_COPY(item->contact->address2, (char*)); 3007 LIST_COPY(item->contact->address2, (char*));
2875 DEBUG_EMAIL(("|%s|\n", item->contact->address2)); 3008 DEBUG_EMAIL(("|%s|\n", item->contact->address2));
2876 break; 3009 break;
2877 case 0x8094: // Email Address 2 Description 3010 case 0x8094: // Email Address 2 Description
2878 DEBUG_EMAIL (("Email Address 2 Description - ")); 3011 DEBUG_EMAIL (("Email Address 2 Description - "));
2879 MALLOC_CONTACT(item); 3012 MALLOC_CONTACT(item);
2880 LIST_COPY(item->contact->address2_desc, (char*)); 3013 LIST_COPY(item->contact->address2_desc, (char*));
2881 DEBUG_EMAIL(("|%s|\n", item->contact->address2_desc)); 3014 DEBUG_EMAIL(("|%s|\n", item->contact->address2_desc));
2882 break; 3015 break;
2883 case 0x8095: // Email Address 2 Record 3016 case 0x8095: // Email Address 2 Record
2884 DEBUG_EMAIL(("Email Address 2 Record - ")); 3017 DEBUG_EMAIL(("Email Address 2 Record - "));
2885 MALLOC_CONTACT(item); 3018 MALLOC_CONTACT(item);
2886 LIST_COPY(item->contact->address2a, (char*)); 3019 LIST_COPY(item->contact->address2a, (char*));
2887 DEBUG_EMAIL(("|%s|\n", item->contact->address2a)); 3020 DEBUG_EMAIL(("|%s|\n", item->contact->address2a));
2888 break; 3021 break;
2889 case 0x80A2: // Email Address 3 Transport 3022 case 0x80A2: // Email Address 3 Transport
2890 DEBUG_EMAIL (("Email Address 3 Transport - ")); 3023 DEBUG_EMAIL (("Email Address 3 Transport - "));
2891 MALLOC_CONTACT(item); 3024 MALLOC_CONTACT(item);
2892 LIST_COPY(item->contact->address3_transport, (char*)); 3025 LIST_COPY(item->contact->address3_transport, (char*));
2893 DEBUG_EMAIL(("|%s|\n", item->contact->address3_transport)); 3026 DEBUG_EMAIL(("|%s|\n", item->contact->address3_transport));
2894 break; 3027 break;
2895 case 0x80A3: // Email Address 3 Address 3028 case 0x80A3: // Email Address 3 Address
2896 DEBUG_EMAIL(("Email Address 3 Address - ")); 3029 DEBUG_EMAIL(("Email Address 3 Address - "));
2897 MALLOC_CONTACT(item); 3030 MALLOC_CONTACT(item);
2898 LIST_COPY(item->contact->address3, (char*)); 3031 LIST_COPY(item->contact->address3, (char*));
2899 DEBUG_EMAIL(("|%s|\n", item->contact->address3)); 3032 DEBUG_EMAIL(("|%s|\n", item->contact->address3));
2900 break; 3033 break;
2901 case 0x80A4: // Email Address 3 Description 3034 case 0x80A4: // Email Address 3 Description
2902 DEBUG_EMAIL(("Email Address 3 Description - ")); 3035 DEBUG_EMAIL(("Email Address 3 Description - "));
2903 MALLOC_CONTACT(item); 3036 MALLOC_CONTACT(item);
2904 LIST_COPY(item->contact->address3_desc, (char*)); 3037 LIST_COPY(item->contact->address3_desc, (char*));
2905 DEBUG_EMAIL(("|%s|\n", item->contact->address3_desc)); 3038 DEBUG_EMAIL(("|%s|\n", item->contact->address3_desc));
2906 break; 3039 break;
2907 case 0x80A5: // Email Address 3 Record 3040 case 0x80A5: // Email Address 3 Record
2908 DEBUG_EMAIL(("Email Address 3 Record - ")); 3041 DEBUG_EMAIL(("Email Address 3 Record - "));
2909 MALLOC_CONTACT(item); 3042 MALLOC_CONTACT(item);
2910 LIST_COPY(item->contact->address3a, (char*)); 3043 LIST_COPY(item->contact->address3a, (char*));
2911 DEBUG_EMAIL(("|%s|\n", item->contact->address3a)); 3044 DEBUG_EMAIL(("|%s|\n", item->contact->address3a));
2912 break; 3045 break;
2913 case 0x80D8: // Internet Free/Busy 3046 case 0x80D8: // Internet Free/Busy
2914 DEBUG_EMAIL(("Internet Free/Busy - ")); 3047 DEBUG_EMAIL(("Internet Free/Busy - "));
2915 MALLOC_CONTACT(item); 3048 MALLOC_CONTACT(item);
2916 LIST_COPY(item->contact->free_busy_address, (char*)); 3049 LIST_COPY(item->contact->free_busy_address, (char*));
2917 DEBUG_EMAIL(("%s\n", item->contact->free_busy_address)); 3050 DEBUG_EMAIL(("%s\n", item->contact->free_busy_address));
2918 break; 3051 break;
2919 case 0x8205: // Show on Free/Busy as 3052 case 0x8205: // Show on Free/Busy as
2920 // 0: Free 3053 // 0: Free
2921 // 1: Tentative 3054 // 1: Tentative
2922 // 2: Busy 3055 // 2: Busy
2923 // 3: Out Of Office 3056 // 3: Out Of Office
2924 DEBUG_EMAIL(("Appointment shows as - ")); 3057 DEBUG_EMAIL(("Appointment shows as - "));
2925 MALLOC_APPOINTMENT(item); 3058 MALLOC_APPOINTMENT(item);
2926 memcpy(&(item->appointment->showas), list->items[x]->data, sizeof(item->appointment->showas)); 3059 memcpy(&(item->appointment->showas), list->items[x]->data, sizeof(item->appointment->showas));
2927 LE32_CPU(item->appointment->showas); 3060 LE32_CPU(item->appointment->showas);
2928 switch (item->appointment->showas) { 3061 switch (item->appointment->showas) {
2929 case PST_FREEBUSY_FREE: 3062 case PST_FREEBUSY_FREE:
2930 DEBUG_EMAIL(("Free\n")); break; 3063 DEBUG_EMAIL(("Free\n")); break;
2931 case PST_FREEBUSY_TENTATIVE: 3064 case PST_FREEBUSY_TENTATIVE:
2932 DEBUG_EMAIL(("Tentative\n")); break; 3065 DEBUG_EMAIL(("Tentative\n")); break;
2933 case PST_FREEBUSY_BUSY: 3066 case PST_FREEBUSY_BUSY:
2934 DEBUG_EMAIL(("Busy\n")); break; 3067 DEBUG_EMAIL(("Busy\n")); break;
2935 case PST_FREEBUSY_OUT_OF_OFFICE: 3068 case PST_FREEBUSY_OUT_OF_OFFICE:
2936 DEBUG_EMAIL(("Out Of Office\n")); break; 3069 DEBUG_EMAIL(("Out Of Office\n")); break;
2937 default: 3070 default:
2938 DEBUG_EMAIL(("Unknown Value: %d\n", item->appointment->showas)); break; 3071 DEBUG_EMAIL(("Unknown Value: %d\n", item->appointment->showas)); break;
2939 } 3072 }
2940 break; 3073 break;
2941 case 0x8208: // Location of an appointment 3074 case 0x8208: // Location of an appointment
2942 DEBUG_EMAIL(("Appointment Location - ")); 3075 DEBUG_EMAIL(("Appointment Location - "));
2943 MALLOC_APPOINTMENT(item); 3076 MALLOC_APPOINTMENT(item);
2944 LIST_COPY(item->appointment->location, (char*)); 3077 LIST_COPY(item->appointment->location, (char*));
2945 DEBUG_EMAIL(("%s\n", item->appointment->location)); 3078 DEBUG_EMAIL(("%s\n", item->appointment->location));
2946 break; 3079 break;
2947 case 0x8214: // Label for an appointment 3080 case 0x8214: // Label for an appointment
2948 DEBUG_EMAIL(("Label for appointment - ")); 3081 DEBUG_EMAIL(("Label for appointment - "));
2949 MALLOC_APPOINTMENT(item); 3082 MALLOC_APPOINTMENT(item);
2950 memcpy(&(item->appointment->label), list->items[x]->data, sizeof(item->appointment->label)); 3083 memcpy(&(item->appointment->label), list->items[x]->data, sizeof(item->appointment->label));
2951 LE32_CPU(item->appointment->label); 3084 LE32_CPU(item->appointment->label);
2952 switch (item->appointment->label) { 3085 switch (item->appointment->label) {
2953 case PST_APP_LABEL_NONE: 3086 case PST_APP_LABEL_NONE:
2954 DEBUG_EMAIL(("None\n")); break; 3087 DEBUG_EMAIL(("None\n")); break;
2955 case PST_APP_LABEL_IMPORTANT: 3088 case PST_APP_LABEL_IMPORTANT:
2956 DEBUG_EMAIL(("Important\n")); break; 3089 DEBUG_EMAIL(("Important\n")); break;
2957 case PST_APP_LABEL_BUSINESS: 3090 case PST_APP_LABEL_BUSINESS:
2958 DEBUG_EMAIL(("Business\n")); break; 3091 DEBUG_EMAIL(("Business\n")); break;
2959 case PST_APP_LABEL_PERSONAL: 3092 case PST_APP_LABEL_PERSONAL:
2960 DEBUG_EMAIL(("Personal\n")); break; 3093 DEBUG_EMAIL(("Personal\n")); break;
2961 case PST_APP_LABEL_VACATION: 3094 case PST_APP_LABEL_VACATION:
2962 DEBUG_EMAIL(("Vacation\n")); break; 3095 DEBUG_EMAIL(("Vacation\n")); break;
2963 case PST_APP_LABEL_MUST_ATTEND: 3096 case PST_APP_LABEL_MUST_ATTEND:
2964 DEBUG_EMAIL(("Must Attend\n")); break; 3097 DEBUG_EMAIL(("Must Attend\n")); break;
2965 case PST_APP_LABEL_TRAVEL_REQ: 3098 case PST_APP_LABEL_TRAVEL_REQ:
2966 DEBUG_EMAIL(("Travel Required\n")); break; 3099 DEBUG_EMAIL(("Travel Required\n")); break;
2967 case PST_APP_LABEL_NEEDS_PREP: 3100 case PST_APP_LABEL_NEEDS_PREP:
2968 DEBUG_EMAIL(("Needs Preparation\n")); break; 3101 DEBUG_EMAIL(("Needs Preparation\n")); break;
2969 case PST_APP_LABEL_BIRTHDAY: 3102 case PST_APP_LABEL_BIRTHDAY:
2970 DEBUG_EMAIL(("Birthday\n")); break; 3103 DEBUG_EMAIL(("Birthday\n")); break;
2971 case PST_APP_LABEL_ANNIVERSARY: 3104 case PST_APP_LABEL_ANNIVERSARY:
2972 DEBUG_EMAIL(("Anniversary\n")); break; 3105 DEBUG_EMAIL(("Anniversary\n")); break;
2973 case PST_APP_LABEL_PHONE_CALL: 3106 case PST_APP_LABEL_PHONE_CALL:
2974 DEBUG_EMAIL(("Phone Call\n")); break; 3107 DEBUG_EMAIL(("Phone Call\n")); break;
2975 } 3108 }
2976 break; 3109 break;
2977 case 0x8215: // All day appointment flag 3110 case 0x8215: // All day appointment flag
2978 DEBUG_EMAIL(("All day flag - ")); 3111 DEBUG_EMAIL(("All day flag - "));
2979 MALLOC_APPOINTMENT(item); 3112 MALLOC_APPOINTMENT(item);
2980 if (*(int16_t*)list->items[x]->data != 0) { 3113 if (*(int16_t*)list->items[x]->data != 0) {
2981 DEBUG_EMAIL(("True\n")); 3114 DEBUG_EMAIL(("True\n"));
2982 item->appointment->all_day = 1; 3115 item->appointment->all_day = 1;
2983 } else { 3116 } else {
2984 DEBUG_EMAIL(("False\n")); 3117 DEBUG_EMAIL(("False\n"));
2985 item->appointment->all_day = 0; 3118 item->appointment->all_day = 0;
2986 } 3119 }
2987 break; 3120 break;
2988 case 0x8234: // TimeZone as String 3121 case 0x8234: // TimeZone as String
2989 DEBUG_EMAIL(("TimeZone of times - ")); 3122 DEBUG_EMAIL(("TimeZone of times - "));
2990 MALLOC_APPOINTMENT(item); 3123 MALLOC_APPOINTMENT(item);
2991 LIST_COPY(item->appointment->timezonestring, (char*)); 3124 LIST_COPY(item->appointment->timezonestring, (char*));
2992 DEBUG_EMAIL(("%s\n", item->appointment->timezonestring)); 3125 DEBUG_EMAIL(("%s\n", item->appointment->timezonestring));
2993 break; 3126 break;
2994 case 0x8235: // Appointment start time 3127 case 0x8235: // Appointment start time
2995 DEBUG_EMAIL(("Appointment Start Time - ")); 3128 DEBUG_EMAIL(("Appointment Start Time - "));
2996 MALLOC_APPOINTMENT(item); 3129 MALLOC_APPOINTMENT(item);
2997 LIST_COPY(item->appointment->start, (FILETIME*)); 3130 LIST_COPY(item->appointment->start, (FILETIME*));
2998 DEBUG_EMAIL(("%s\n", fileTimeToAscii((FILETIME*)item->appointment->start))); 3131 DEBUG_EMAIL(("%s\n", fileTimeToAscii((FILETIME*)item->appointment->start)));
2999 break; 3132 break;
3000 case 0x8236: // Appointment end time 3133 case 0x8236: // Appointment end time
3001 DEBUG_EMAIL(("Appointment End Time - ")); 3134 DEBUG_EMAIL(("Appointment End Time - "));
3002 MALLOC_APPOINTMENT(item); 3135 MALLOC_APPOINTMENT(item);
3003 LIST_COPY(item->appointment->end, (FILETIME*)); 3136 LIST_COPY(item->appointment->end, (FILETIME*));
3004 DEBUG_EMAIL(("%s\n", fileTimeToAscii((FILETIME*)item->appointment->start))); 3137 DEBUG_EMAIL(("%s\n", fileTimeToAscii((FILETIME*)item->appointment->start)));
3005 break; 3138 break;
3006 case 0x8516: // Journal time start 3139 case 0x8516: // Journal time start
3007 DEBUG_EMAIL(("Duplicate Time Start - ")); 3140 DEBUG_EMAIL(("Duplicate Time Start - "));
3008 DEBUG_EMAIL(("%s\n", fileTimeToAscii((FILETIME*)list->items[x]->data))); 3141 DEBUG_EMAIL(("%s\n", fileTimeToAscii((FILETIME*)list->items[x]->data)));
3009 break; 3142 break;
3010 case 0x8517: // Journal time end 3143 case 0x8517: // Journal time end
3011 DEBUG_EMAIL(("Duplicate Time End - ")); 3144 DEBUG_EMAIL(("Duplicate Time End - "));
3012 DEBUG_EMAIL(("%s\n", fileTimeToAscii((FILETIME*)list->items[x]->data))); 3145 DEBUG_EMAIL(("%s\n", fileTimeToAscii((FILETIME*)list->items[x]->data)));
3013 break; 3146 break;
3014 case 0x8530: // Followup 3147 case 0x8530: // Followup
3015 DEBUG_EMAIL(("Followup String - ")); 3148 DEBUG_EMAIL(("Followup String - "));
3016 MALLOC_CONTACT(item); 3149 MALLOC_CONTACT(item);
3017 LIST_COPY(item->contact->followup, (char*)); 3150 LIST_COPY(item->contact->followup, (char*));
3018 DEBUG_EMAIL(("%s\n", item->contact->followup)); 3151 DEBUG_EMAIL(("%s\n", item->contact->followup));
3019 break; 3152 break;
3020 case 0x8534: // Mileage 3153 case 0x8534: // Mileage
3021 DEBUG_EMAIL(("Mileage - ")); 3154 DEBUG_EMAIL(("Mileage - "));
3022 MALLOC_CONTACT(item); 3155 MALLOC_CONTACT(item);
3023 LIST_COPY(item->contact->mileage, (char*)); 3156 LIST_COPY(item->contact->mileage, (char*));
3024 DEBUG_EMAIL(("%s\n", item->contact->mileage)); 3157 DEBUG_EMAIL(("%s\n", item->contact->mileage));
3025 break; 3158 break;
3026 case 0x8535: // Billing Information 3159 case 0x8535: // Billing Information
3027 DEBUG_EMAIL(("Billing Information - ")); 3160 DEBUG_EMAIL(("Billing Information - "));
3028 MALLOC_CONTACT(item); 3161 MALLOC_CONTACT(item);
3029 LIST_COPY(item->contact->billing_information, (char*)); 3162 LIST_COPY(item->contact->billing_information, (char*));
3030 DEBUG_EMAIL(("%s\n", item->contact->billing_information)); 3163 DEBUG_EMAIL(("%s\n", item->contact->billing_information));
3031 break; 3164 break;
3032 case 0x8554: // Outlook Version 3165 case 0x8554: // Outlook Version
3033 DEBUG_EMAIL(("Outlook Version - ")); 3166 DEBUG_EMAIL(("Outlook Version - "));
3034 LIST_COPY(item->outlook_version, (char*)); 3167 LIST_COPY(item->outlook_version, (char*));
3035 DEBUG_EMAIL(("%s\n", item->outlook_version)); 3168 DEBUG_EMAIL(("%s\n", item->outlook_version));
3036 break; 3169 break;
3037 case 0x8560: // Appointment Reminder Time 3170 case 0x8560: // Appointment Reminder Time
3038 DEBUG_EMAIL(("Appointment Reminder Time - ")); 3171 DEBUG_EMAIL(("Appointment Reminder Time - "));
3039 MALLOC_APPOINTMENT(item); 3172 MALLOC_APPOINTMENT(item);
3040 LIST_COPY(item->appointment->reminder, (FILETIME*)); 3173 LIST_COPY(item->appointment->reminder, (FILETIME*));
3041 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->appointment->reminder))); 3174 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->appointment->reminder)));
3042 break; 3175 break;
3043 case 0x8700: // Journal Type 3176 case 0x8700: // Journal Type
3044 DEBUG_EMAIL(("Journal Entry Type - ")); 3177 DEBUG_EMAIL(("Journal Entry Type - "));
3045 MALLOC_JOURNAL(item); 3178 MALLOC_JOURNAL(item);
3046 LIST_COPY(item->journal->type, (char*)); 3179 LIST_COPY(item->journal->type, (char*));
3047 DEBUG_EMAIL(("%s\n", item->journal->type)); 3180 DEBUG_EMAIL(("%s\n", item->journal->type));
3048 break; 3181 break;
3049 case 0x8706: // Journal Start date/time 3182 case 0x8706: // Journal Start date/time
3050 DEBUG_EMAIL(("Start Timestamp - ")); 3183 DEBUG_EMAIL(("Start Timestamp - "));
3051 MALLOC_JOURNAL(item); 3184 MALLOC_JOURNAL(item);
3052 LIST_COPY(item->journal->start, (FILETIME*)); 3185 LIST_COPY(item->journal->start, (FILETIME*));
3053 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->journal->start))); 3186 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->journal->start)));
3054 break; 3187 break;
3055 case 0x8708: // Journal End date/time 3188 case 0x8708: // Journal End date/time
3056 DEBUG_EMAIL(("End Timestamp - ")); 3189 DEBUG_EMAIL(("End Timestamp - "));
3057 MALLOC_JOURNAL(item); 3190 MALLOC_JOURNAL(item);
3058 LIST_COPY(item->journal->end, (FILETIME*)); 3191 LIST_COPY(item->journal->end, (FILETIME*));
3059 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->journal->end))); 3192 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->journal->end)));
3060 break; 3193 break;
3061 case 0x8712: // Title? 3194 case 0x8712: // Title?
3062 DEBUG_EMAIL(("Journal Entry Type - ")); 3195 DEBUG_EMAIL(("Journal Entry Type - "));
3063 MALLOC_JOURNAL(item); 3196 MALLOC_JOURNAL(item);
3064 LIST_COPY(item->journal->type, (char*)); 3197 LIST_COPY(item->journal->type, (char*));
3065 DEBUG_EMAIL(("%s\n", item->journal->type)); 3198 DEBUG_EMAIL(("%s\n", item->journal->type));
3066 break; 3199 break;
3067 default: 3200 default:
3068 DEBUG_EMAIL(("unknown type %#x\n", list->items[x]->id)); 3201 DEBUG_EMAIL(("unknown type %#x\n", list->items[x]->id));
3069 /* Reference Types 3202 /* Reference Types
3070 3203
3071 2 - 0x0002 - Signed 16bit value 3204 2 - 0x0002 - Signed 16bit value
3072 3 - 0x0003 - Signed 32bit value 3205 3 - 0x0003 - Signed 32bit value
3073 11 - 0x000B - Boolean (non-zero = true) 3206 11 - 0x000B - Boolean (non-zero = true)
3074 13 - 0x000D - Embedded Object 3207 13 - 0x000D - Embedded Object
3075 30 - 0x001E - Null terminated String 3208 30 - 0x001E - Null terminated String
3076 31 - 0x001F - Unicode string 3209 31 - 0x001F - Unicode string
3077 64 - 0x0040 - Systime - Filetime structure 3210 64 - 0x0040 - Systime - Filetime structure
3078 72 - 0x0048 - OLE Guid 3211 72 - 0x0048 - OLE Guid
3079 258 - 0x0102 - Binary data 3212 258 - 0x0102 - Binary data
3080 3213
3081 - 0x1003 - Array of 32bit values 3214 - 0x1003 - Array of 32bit values
3082 - 0x101E - Array of Strings 3215 - 0x101E - Array of Strings
3083 - 0x1102 - Array of Binary data 3216 - 0x1102 - Array of Binary data
3084 */ 3217 */
3085 // DEBUG_EMAIL(("Unknown id [%#x, size=%#x]\n", list->items[x]->id, list->items[x]->size)); 3218 // DEBUG_EMAIL(("Unknown id [%#x, size=%#x]\n", list->items[x]->id, list->items[x]->size));
3086 if (list->items[x]->type == 0x02) { 3219 if (list->items[x]->type == 0x02) {
3087 DEBUG_EMAIL(("Unknown 16bit int = %hi\n", *(int16_t*)list->items[x]->data)); 3220 DEBUG_EMAIL(("Unknown 16bit int = %hi\n", *(int16_t*)list->items[x]->data));
3088 } else if (list->items[x]->type == 0x03) { 3221 } else if (list->items[x]->type == 0x03) {
3089 DEBUG_EMAIL(("Unknown 32bit int = %i\n", *(int32_t*)list->items[x]->data)); 3222 DEBUG_EMAIL(("Unknown 32bit int = %i\n", *(int32_t*)list->items[x]->data));
3090 } else if (list->items[x]->type == 0x0b) { 3223 } else if (list->items[x]->type == 0x0b) {
3091 DEBUG_EMAIL(("Unknown 16bit boolean = %s [%hi]\n", 3224 DEBUG_EMAIL(("Unknown 16bit boolean = %s [%hi]\n",
3092 (*((int16_t*)list->items[x]->data)!=0?"True":"False"), 3225 (*((int16_t*)list->items[x]->data)!=0?"True":"False"),
3093 *((int16_t*)list->items[x]->data))); 3226 *((int16_t*)list->items[x]->data)));
3094 } else if (list->items[x]->type == 0x1e) { 3227 } else if (list->items[x]->type == 0x1e) {
3095 DEBUG_EMAIL(("Unknown String Data = \"%s\" [%#x]\n", 3228 DEBUG_EMAIL(("Unknown String Data = \"%s\" [%#x]\n",
3096 list->items[x]->data, list->items[x]->type)); 3229 list->items[x]->data, list->items[x]->type));
3097 } else if (list->items[x]->type == 0x40) { 3230 } else if (list->items[x]->type == 0x40) {
3098 DEBUG_EMAIL(("Unknown Date = \"%s\" [%#x]\n", 3231 DEBUG_EMAIL(("Unknown Date = \"%s\" [%#x]\n",
3099 fileTimeToAscii((FILETIME*)list->items[x]->data), 3232 fileTimeToAscii((FILETIME*)list->items[x]->data),
3100 list->items[x]->type)); 3233 list->items[x]->type));
3101 } else if (list->items[x]->type == 0x102) { 3234 } else if (list->items[x]->type == 0x102) {
3102 DEBUG_EMAIL(("Unknown Binary Data [size = %#x]\n", 3235 DEBUG_EMAIL(("Unknown Binary Data [size = %#x]\n",
3103 list->items[x]->size)); 3236 list->items[x]->size));
3104 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); 3237 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size);
3105 } else if (list->items[x]->type == 0x101E) { 3238 } else if (list->items[x]->type == 0x101E) {
3106 DEBUG_EMAIL(("Unknown Array of Strings [%#x]\n", 3239 DEBUG_EMAIL(("Unknown Array of Strings [%#x]\n",
3107 list->items[x]->type)); 3240 list->items[x]->type));
3108 } else { 3241 } else {
3109 DEBUG_EMAIL(("Unknown Not Printable [%#x]\n", 3242 DEBUG_EMAIL(("Unknown Not Printable [%#x]\n",
3110 list->items[x]->type)); 3243 list->items[x]->type));
3111 } 3244 }
3112 if (list->items[x]->data) { 3245 if (list->items[x]->data) {
3113 free(list->items[x]->data); 3246 free(list->items[x]->data);
3114 list->items[x]->data = NULL; 3247 list->items[x]->data = NULL;
3115 } 3248 }
3116 } 3249 }
3117 x++; 3250 x++;
3118 } 3251 }
3119 x = 0; 3252 x = 0;
3120 list = list->next; 3253 list = list->next;
3121 next = 1; 3254 next = 1;
3122 } 3255 }
3123 DEBUG_RET(); 3256 DEBUG_RET();
3124 return 0; 3257 return 0;
3125 } 3258 }
3126 3259
3127 3260
3128 int32_t _pst_free_list(pst_num_array *list) { 3261 int32_t _pst_free_list(pst_num_array *list) {
3129 pst_num_array *l; 3262 pst_num_array *l;
3130 DEBUG_ENT("_pst_free_list"); 3263 DEBUG_ENT("_pst_free_list");
3131 while (list) { 3264 while (list) {
3132 if (list->items) { 3265 if (list->items) {
3133 int32_t x; 3266 int32_t x;
3134 for (x=0; x < list->orig_count; x++) { 3267 for (x=0; x < list->orig_count; x++) {
3135 if (list->items[x]) { 3268 if (list->items[x]) {
3136 if (list->items[x]->data) free(list->items[x]->data); 3269 if (list->items[x]->data) free(list->items[x]->data);
3137 free(list->items[x]); 3270 free(list->items[x]);
3138 } 3271 }
3139 } 3272 }
3140 free(list->items); 3273 free(list->items);
3141 } 3274 }
3142 l = list; 3275 l = list;
3143 list = list->next; 3276 list = list->next;
3144 free (l); 3277 free (l);
3145 } 3278 }
3146 DEBUG_RET(); 3279 DEBUG_RET();
3147 return 1; 3280 return 1;
3148 } 3281 }
3149 3282
3150 3283
3151 int32_t _pst_free_id2(pst_index2_ll * head) { 3284 int32_t _pst_free_id2(pst_index2_ll * head) {
3152 pst_index2_ll *t; 3285 pst_index2_ll *t;
3153 DEBUG_ENT("_pst_free_id2"); 3286 DEBUG_ENT("_pst_free_id2");
3154 while (head) { 3287 while (head) {
3155 t = head->next; 3288 t = head->next;
3156 free (head); 3289 free (head);
3157 head = t; 3290 head = t;
3158 } 3291 }
3159 DEBUG_RET(); 3292 DEBUG_RET();
3160 return 1; 3293 return 1;
3161 } 3294 }
3162 3295
3163 3296
3164 int32_t _pst_free_id (pst_index_ll *head) { 3297 int32_t _pst_free_id (pst_index_ll *head) {
3165 pst_index_ll *t; 3298 pst_index_ll *t;
3166 DEBUG_ENT("_pst_free_id"); 3299 DEBUG_ENT("_pst_free_id");
3167 while (head) { 3300 while (head) {
3168 t = head->next; 3301 t = head->next;
3169 free(head); 3302 free(head);
3170 head = t; 3303 head = t;
3171 } 3304 }
3172 DEBUG_RET(); 3305 DEBUG_RET();
3173 return 1; 3306 return 1;
3174 } 3307 }
3175 3308
3176 3309
3177 int32_t _pst_free_desc (pst_desc_ll *head) { 3310 int32_t _pst_free_desc (pst_desc_ll *head) {
3178 pst_desc_ll *t; 3311 pst_desc_ll *t;
3179 DEBUG_ENT("_pst_free_desc"); 3312 DEBUG_ENT("_pst_free_desc");
3180 while (head) { 3313 while (head) {
3181 while (head->child) { 3314 while (head->child) {
3182 head = head->child; 3315 head = head->child;
3183 } 3316 }
3184 3317
3185 // point t to the next item 3318 // point t to the next item
3186 t = head->next; 3319 t = head->next;
3187 if (!t && head->parent) { 3320 if (!t && head->parent) {
3188 t = head->parent; 3321 t = head->parent;
3189 t->child = NULL; // set the child to NULL so we don't come back here again! 3322 t->child = NULL; // set the child to NULL so we don't come back here again!
3190 } 3323 }
3191 3324
3192 if (head) free(head); 3325 if (head) free(head);
3193 else DIE(("head is NULL")); 3326 else DIE(("head is NULL"));
3194 3327
3195 head = t; 3328 head = t;
3196 } 3329 }
3197 DEBUG_RET(); 3330 DEBUG_RET();
3198 return 1; 3331 return 1;
3199 } 3332 }
3200 3333
3201 3334
3202 int32_t _pst_free_xattrib(pst_x_attrib_ll *x) { 3335 int32_t _pst_free_xattrib(pst_x_attrib_ll *x) {
3203 pst_x_attrib_ll *t; 3336 pst_x_attrib_ll *t;
3204 DEBUG_ENT("_pst_free_xattrib"); 3337 DEBUG_ENT("_pst_free_xattrib");
3205 while (x) { 3338 while (x) {
3206 if (x->data) free(x->data); 3339 if (x->data) free(x->data);
3207 t = x->next; 3340 t = x->next;
3208 free(x); 3341 free(x);
3209 x = t; 3342 x = t;
3210 } 3343 }
3211 DEBUG_RET(); 3344 DEBUG_RET();
3212 return 1; 3345 return 1;
3213 } 3346 }
3214 3347
3215 3348
3216 pst_index2_ll * _pst_build_id2(pst_file *pf, pst_index_ll* list, pst_index2_ll* head_ptr) { 3349 pst_index2_ll * _pst_build_id2(pst_file *pf, pst_index_ll* list, pst_index2_ll* head_ptr) {
3217 pst_block_header block_head; 3350 pst_block_header block_head;
3218 pst_index2_ll *head = NULL, *tail = NULL; 3351 pst_index2_ll *head = NULL, *tail = NULL;
3219 int32_t x = 0, b_ptr = 0; 3352 int32_t x = 0, b_ptr = 0;
3220 char *buf = NULL; 3353 char *buf = NULL;
3221 pst_id2_assoc id2_rec; 3354 pst_id2_assoc id2_rec;
3222 pst_index_ll *i_ptr = NULL; 3355 pst_index_ll *i_ptr = NULL;
3223 pst_index2_ll *i2_ptr = NULL; 3356 pst_index2_ll *i2_ptr = NULL;
3224 DEBUG_ENT("_pst_build_id2"); 3357 DEBUG_ENT("_pst_build_id2");
3225 3358
3226 if (head_ptr) { 3359 if (head_ptr) {
3227 head = head_ptr; 3360 head = head_ptr;
3228 while (head_ptr) head_ptr = (tail = head_ptr)->next; 3361 while (head_ptr) head_ptr = (tail = head_ptr)->next;
3229 } 3362 }
3230 if (_pst_read_block_size(pf, list->offset, list->size, &buf, PST_NO_ENC, 0) < list->size) { 3363 if (_pst_read_block_size(pf, list->offset, list->size, &buf, PST_NO_ENC, 0) < list->size) {
3231 //an error occured in block read 3364 //an error occured in block read
3232 WARN(("block read error occured. offset = %#x, size = %#x\n", list->offset, list->size)); 3365 WARN(("block read error occured. offset = %#llx, size = %#llx\n", list->offset, list->size));
3233 if (buf) free(buf); 3366 if (buf) free(buf);
3234 DEBUG_RET(); 3367 DEBUG_RET();
3235 return NULL; 3368 return NULL;
3236 } 3369 }
3237 DEBUG_HEXDUMPC(buf, list->size, 16); 3370 DEBUG_HEXDUMPC(buf, list->size, 16);
3238 3371
3239 memcpy(&block_head, buf, sizeof(block_head)); 3372 memcpy(&block_head, buf, sizeof(block_head));
3240 LE16_CPU(block_head.type); 3373 LE16_CPU(block_head.type);
3241 LE16_CPU(block_head.count); 3374 LE16_CPU(block_head.count);
3242 3375
3243 if (block_head.type != 0x0002) { // some sort of constant? 3376 if (block_head.type != 0x0002) { // some sort of constant?
3244 WARN(("Unknown constant [%#x] at start of id2 values [offset %#x].\n", block_head.type, list->offset)); 3377 WARN(("Unknown constant [%#x] at start of id2 values [offset %#llx].\n", block_head.type, list->offset));
3245 if (buf) free(buf); 3378 if (buf) free(buf);
3246 DEBUG_RET(); 3379 DEBUG_RET();
3247 return NULL; 3380 return NULL;
3248 } 3381 }
3249 3382
3250 DEBUG_INDEX(("ID %#x is likely to be a description record. Count is %i (offset %#x)\n", 3383 DEBUG_INDEX(("ID %#x is likely to be a description record. Count is %i (offset %#x)\n",
3251 list->id, block_head.count, list->offset)); 3384 list->id, block_head.count, list->offset));
3252 x = 0; 3385 x = 0;
3253 b_ptr = 0x04; 3386 b_ptr = 0x04;
3254 while (x < block_head.count) { 3387 while (x < block_head.count) {
3255 memcpy(&id2_rec, &(buf[b_ptr]), sizeof(id2_rec)); 3388 memcpy(&id2_rec, &(buf[b_ptr]), sizeof(id2_rec));
3256 LE32_CPU(id2_rec.id2); 3389 LE32_CPU(id2_rec.id2);
3257 LE32_CPU(id2_rec.id); 3390 LE32_CPU(id2_rec.id);
3258 LE32_CPU(id2_rec.table2); 3391 LE32_CPU(id2_rec.table2);
3259 3392
3260 b_ptr += sizeof(id2_rec); 3393 b_ptr += sizeof(id2_rec);
3261 DEBUG_INDEX(("\tid2 = %#x, id = %#x, table2 = %#x\n", id2_rec.id2, id2_rec.id, id2_rec.table2)); 3394 DEBUG_INDEX(("\tid2 = %#x, id = %#x, table2 = %#x\n", id2_rec.id2, id2_rec.id, id2_rec.table2));
3262 if ((i_ptr = _pst_getID(pf, id2_rec.id)) == NULL) { 3395 if ((i_ptr = _pst_getID(pf, id2_rec.id)) == NULL) {
3263 DEBUG_WARN(("\t\t%#x - Not Found\n", id2_rec.id)); 3396 DEBUG_WARN(("\t\t%#x - Not Found\n", id2_rec.id));
3264 } else { 3397 } else {
3265 DEBUG_INDEX(("\t\t%#x - Offset %#x, u1 %#x, Size %i(%#x)\n", i_ptr->id, i_ptr->offset, i_ptr->u1, i_ptr->size, i_ptr->size)); 3398 DEBUG_INDEX(("\t\t%#x - Offset %#x, u1 %#x, Size %i(%#x)\n", i_ptr->id, i_ptr->offset, i_ptr->u1, i_ptr->size, i_ptr->size));
3266 // add it to the linked list 3399 // add it to the linked list
3267 i2_ptr = (pst_index2_ll*) xmalloc(sizeof(pst_index2_ll)); 3400 i2_ptr = (pst_index2_ll*) xmalloc(sizeof(pst_index2_ll));
3268 i2_ptr->id2 = id2_rec.id2; 3401 i2_ptr->id2 = id2_rec.id2;
3269 i2_ptr->id = i_ptr; 3402 i2_ptr->id = i_ptr;
3270 i2_ptr->next = NULL; 3403 i2_ptr->next = NULL;
3271 if (!head) head = i2_ptr; 3404 if (!head) head = i2_ptr;
3272 if (tail) tail->next = i2_ptr; 3405 if (tail) tail->next = i2_ptr;
3273 tail = i2_ptr; 3406 tail = i2_ptr;
3274 if (id2_rec.table2 != 0) { 3407 if (id2_rec.table2 != 0) {
3275 if ((i_ptr = _pst_getID(pf, id2_rec.table2)) == NULL) { 3408 if ((i_ptr = _pst_getID(pf, id2_rec.table2)) == NULL) {
3276 DEBUG_WARN(("\tTable2 [%#x] not found\n", id2_rec.table2)); 3409 DEBUG_WARN(("\tTable2 [%#x] not found\n", id2_rec.table2));
3277 } 3410 }
3278 else { 3411 else {
3279 DEBUG_INDEX(("\tGoing deeper for table2 [%#x]\n", id2_rec.table2)); 3412 DEBUG_INDEX(("\tGoing deeper for table2 [%#x]\n", id2_rec.table2));
3280 if ((i2_ptr = _pst_build_id2(pf, i_ptr, head))) { 3413 if ((i2_ptr = _pst_build_id2(pf, i_ptr, head))) {
3281 // DEBUG_INDEX(("_pst_build_id2(): \t\tAdding new list onto end of current\n")); 3414 // DEBUG_INDEX(("_pst_build_id2(): \t\tAdding new list onto end of current\n"));
3282 // if (!head) 3415 // if (!head)
3283 // head = i2_ptr; 3416 // head = i2_ptr;
3284 // if (tail) 3417 // if (tail)
3285 // tail->next = i2_ptr; 3418 // tail->next = i2_ptr;
3286 // while (i2_ptr->next) 3419 // while (i2_ptr->next)
3287 // i2_ptr = i2_ptr->next; 3420 // i2_ptr = i2_ptr->next;
3288 // tail = i2_ptr; 3421 // tail = i2_ptr;
3289 } 3422 }
3290 // need to re-establish tail 3423 // need to re-establish tail
3291 DEBUG_INDEX(("Returned from depth\n")); 3424 DEBUG_INDEX(("Returned from depth\n"));
3292 if (tail) { 3425 if (tail) {
3293 while (tail->next) tail = tail->next; 3426 while (tail->next) tail = tail->next;
3294 } 3427 }
3295 } 3428 }
3296 } 3429 }
3297 } 3430 }
3298 x++; 3431 x++;
3299 } 3432 }
3300 if (buf) free (buf); 3433 if (buf) free (buf);
3301 DEBUG_RET(); 3434 DEBUG_RET();
3302 return head; 3435 return head;
3303 } 3436 }
3304 3437
3305 3438
3306 // This version of free does NULL check first 3439 // This version of free does NULL check first
3307 #define SAFE_FREE(x) {if (x) free(x);} 3440 #define SAFE_FREE(x) {if (x) free(x);}
3308 3441
3309 void _pst_freeItem(pst_item *item) { 3442 void _pst_freeItem(pst_item *item) {
3310 pst_item_attach *t; 3443 pst_item_attach *t;
3311 pst_item_extra_field *et; 3444 pst_item_extra_field *et;
3312 3445
3313 DEBUG_ENT("_pst_freeItem"); 3446 DEBUG_ENT("_pst_freeItem");
3314 if (item) { 3447 if (item) {
3315 if (item->email) { 3448 if (item->email) {
3316 SAFE_FREE(item->email->arrival_date); 3449 SAFE_FREE(item->email->arrival_date);
3317 SAFE_FREE(item->email->body); 3450 SAFE_FREE(item->email->body);
3318 SAFE_FREE(item->email->cc_address); 3451 SAFE_FREE(item->email->cc_address);
3319 SAFE_FREE(item->email->common_name); 3452 SAFE_FREE(item->email->common_name);
3320 SAFE_FREE(item->email->encrypted_body); 3453 SAFE_FREE(item->email->encrypted_body);
3321 SAFE_FREE(item->email->encrypted_htmlbody); 3454 SAFE_FREE(item->email->encrypted_htmlbody);
3322 SAFE_FREE(item->email->header); 3455 SAFE_FREE(item->email->header);
3323 SAFE_FREE(item->email->htmlbody); 3456 SAFE_FREE(item->email->htmlbody);
3324 SAFE_FREE(item->email->in_reply_to); 3457 SAFE_FREE(item->email->in_reply_to);
3325 SAFE_FREE(item->email->messageid); 3458 SAFE_FREE(item->email->messageid);
3326 SAFE_FREE(item->email->outlook_recipient); 3459 SAFE_FREE(item->email->outlook_recipient);
3327 SAFE_FREE(item->email->outlook_recipient2); 3460 SAFE_FREE(item->email->outlook_recipient2);
3328 SAFE_FREE(item->email->outlook_sender); 3461 SAFE_FREE(item->email->outlook_sender);
3329 SAFE_FREE(item->email->outlook_sender_name); 3462 SAFE_FREE(item->email->outlook_sender_name);
3330 SAFE_FREE(item->email->outlook_sender2); 3463 SAFE_FREE(item->email->outlook_sender2);
3331 SAFE_FREE(item->email->proc_subject); 3464 SAFE_FREE(item->email->proc_subject);
3332 SAFE_FREE(item->email->recip_access); 3465 SAFE_FREE(item->email->recip_access);
3333 SAFE_FREE(item->email->recip_address); 3466 SAFE_FREE(item->email->recip_address);
3334 SAFE_FREE(item->email->recip2_access); 3467 SAFE_FREE(item->email->recip2_access);
3335 SAFE_FREE(item->email->recip2_address); 3468 SAFE_FREE(item->email->recip2_address);
3336 SAFE_FREE(item->email->reply_to); 3469 SAFE_FREE(item->email->reply_to);
3337 SAFE_FREE(item->email->rtf_body_tag); 3470 SAFE_FREE(item->email->rtf_body_tag);
3338 SAFE_FREE(item->email->rtf_compressed); 3471 SAFE_FREE(item->email->rtf_compressed);
3339 SAFE_FREE(item->email->return_path_address); 3472 SAFE_FREE(item->email->return_path_address);
3340 SAFE_FREE(item->email->sender_access); 3473 SAFE_FREE(item->email->sender_access);
3341 SAFE_FREE(item->email->sender_address); 3474 SAFE_FREE(item->email->sender_address);
3342 SAFE_FREE(item->email->sender2_access); 3475 SAFE_FREE(item->email->sender2_access);
3343 SAFE_FREE(item->email->sender2_address); 3476 SAFE_FREE(item->email->sender2_address);
3344 SAFE_FREE(item->email->sent_date); 3477 SAFE_FREE(item->email->sent_date);
3345 SAFE_FREE(item->email->sentmail_folder); 3478 SAFE_FREE(item->email->sentmail_folder);
3346 SAFE_FREE(item->email->sentto_address); 3479 SAFE_FREE(item->email->sentto_address);
3347 if (item->email->subject) 3480 if (item->email->subject)
3348 SAFE_FREE(item->email->subject->subj); 3481 SAFE_FREE(item->email->subject->subj);
3349 SAFE_FREE(item->email->subject); 3482 SAFE_FREE(item->email->subject);
3350 free(item->email); 3483 free(item->email);
3351 } 3484 }
3352 if (item->folder) { 3485 if (item->folder) {
3353 free(item->folder); 3486 free(item->folder);
3354 } 3487 }
3355 if (item->message_store) { 3488 if (item->message_store) {
3356 SAFE_FREE(item->message_store->deleted_items_folder); 3489 SAFE_FREE(item->message_store->deleted_items_folder);
3357 SAFE_FREE(item->message_store->search_root_folder); 3490 SAFE_FREE(item->message_store->search_root_folder);
3358 SAFE_FREE(item->message_store->top_of_personal_folder); 3491 SAFE_FREE(item->message_store->top_of_personal_folder);
3359 SAFE_FREE(item->message_store->top_of_folder); 3492 SAFE_FREE(item->message_store->top_of_folder);
3360 free(item->message_store); 3493 free(item->message_store);
3361 } 3494 }
3362 if (item->contact) { 3495 if (item->contact) {
3363 SAFE_FREE(item->contact->access_method); 3496 SAFE_FREE(item->contact->access_method);
3364 SAFE_FREE(item->contact->account_name); 3497 SAFE_FREE(item->contact->account_name);
3365 SAFE_FREE(item->contact->address1); 3498 SAFE_FREE(item->contact->address1);
3366 SAFE_FREE(item->contact->address1a); 3499 SAFE_FREE(item->contact->address1a);
3367 SAFE_FREE(item->contact->address1_desc); 3500 SAFE_FREE(item->contact->address1_desc);
3368 SAFE_FREE(item->contact->address1_transport); 3501 SAFE_FREE(item->contact->address1_transport);
3369 SAFE_FREE(item->contact->address2); 3502 SAFE_FREE(item->contact->address2);
3370 SAFE_FREE(item->contact->address2a); 3503 SAFE_FREE(item->contact->address2a);
3371 SAFE_FREE(item->contact->address2_desc); 3504 SAFE_FREE(item->contact->address2_desc);
3372 SAFE_FREE(item->contact->address2_transport); 3505 SAFE_FREE(item->contact->address2_transport);
3373 SAFE_FREE(item->contact->address3); 3506 SAFE_FREE(item->contact->address3);
3374 SAFE_FREE(item->contact->address3a); 3507 SAFE_FREE(item->contact->address3a);
3375 SAFE_FREE(item->contact->address3_desc); 3508 SAFE_FREE(item->contact->address3_desc);
3376 SAFE_FREE(item->contact->address3_transport); 3509 SAFE_FREE(item->contact->address3_transport);
3377 SAFE_FREE(item->contact->assistant_name); 3510 SAFE_FREE(item->contact->assistant_name);
3378 SAFE_FREE(item->contact->assistant_phone); 3511 SAFE_FREE(item->contact->assistant_phone);
3379 SAFE_FREE(item->contact->billing_information); 3512 SAFE_FREE(item->contact->billing_information);
3380 SAFE_FREE(item->contact->birthday); 3513 SAFE_FREE(item->contact->birthday);
3381 SAFE_FREE(item->contact->business_address); 3514 SAFE_FREE(item->contact->business_address);
3382 SAFE_FREE(item->contact->business_city); 3515 SAFE_FREE(item->contact->business_city);
3383 SAFE_FREE(item->contact->business_country); 3516 SAFE_FREE(item->contact->business_country);
3384 SAFE_FREE(item->contact->business_fax); 3517 SAFE_FREE(item->contact->business_fax);
3385 SAFE_FREE(item->contact->business_homepage); 3518 SAFE_FREE(item->contact->business_homepage);
3386 SAFE_FREE(item->contact->business_phone); 3519 SAFE_FREE(item->contact->business_phone);
3387 SAFE_FREE(item->contact->business_phone2); 3520 SAFE_FREE(item->contact->business_phone2);
3388 SAFE_FREE(item->contact->business_po_box); 3521 SAFE_FREE(item->contact->business_po_box);
3389 SAFE_FREE(item->contact->business_postal_code); 3522 SAFE_FREE(item->contact->business_postal_code);
3390 SAFE_FREE(item->contact->business_state); 3523 SAFE_FREE(item->contact->business_state);
3391 SAFE_FREE(item->contact->business_street); 3524 SAFE_FREE(item->contact->business_street);
3392 SAFE_FREE(item->contact->callback_phone); 3525 SAFE_FREE(item->contact->callback_phone);
3393 SAFE_FREE(item->contact->car_phone); 3526 SAFE_FREE(item->contact->car_phone);
3394 SAFE_FREE(item->contact->company_main_phone); 3527 SAFE_FREE(item->contact->company_main_phone);
3395 SAFE_FREE(item->contact->company_name); 3528 SAFE_FREE(item->contact->company_name);
3396 SAFE_FREE(item->contact->computer_name); 3529 SAFE_FREE(item->contact->computer_name);
3397 SAFE_FREE(item->contact->customer_id); 3530 SAFE_FREE(item->contact->customer_id);
3398 SAFE_FREE(item->contact->def_postal_address); 3531 SAFE_FREE(item->contact->def_postal_address);
3399 SAFE_FREE(item->contact->department); 3532 SAFE_FREE(item->contact->department);
3400 SAFE_FREE(item->contact->display_name_prefix); 3533 SAFE_FREE(item->contact->display_name_prefix);
3401 SAFE_FREE(item->contact->first_name); 3534 SAFE_FREE(item->contact->first_name);
3402 SAFE_FREE(item->contact->followup); 3535 SAFE_FREE(item->contact->followup);
3403 SAFE_FREE(item->contact->free_busy_address); 3536 SAFE_FREE(item->contact->free_busy_address);
3404 SAFE_FREE(item->contact->ftp_site); 3537 SAFE_FREE(item->contact->ftp_site);
3405 SAFE_FREE(item->contact->fullname); 3538 SAFE_FREE(item->contact->fullname);
3406 SAFE_FREE(item->contact->gov_id); 3539 SAFE_FREE(item->contact->gov_id);
3407 SAFE_FREE(item->contact->hobbies); 3540 SAFE_FREE(item->contact->hobbies);
3408 SAFE_FREE(item->contact->home_address); 3541 SAFE_FREE(item->contact->home_address);
3409 SAFE_FREE(item->contact->home_city); 3542 SAFE_FREE(item->contact->home_city);
3410 SAFE_FREE(item->contact->home_country); 3543 SAFE_FREE(item->contact->home_country);
3411 SAFE_FREE(item->contact->home_fax); 3544 SAFE_FREE(item->contact->home_fax);
3412 SAFE_FREE(item->contact->home_po_box); 3545 SAFE_FREE(item->contact->home_po_box);
3413 SAFE_FREE(item->contact->home_phone); 3546 SAFE_FREE(item->contact->home_phone);
3414 SAFE_FREE(item->contact->home_phone2); 3547 SAFE_FREE(item->contact->home_phone2);
3415 SAFE_FREE(item->contact->home_postal_code); 3548 SAFE_FREE(item->contact->home_postal_code);
3416 SAFE_FREE(item->contact->home_state); 3549 SAFE_FREE(item->contact->home_state);
3417 SAFE_FREE(item->contact->home_street); 3550 SAFE_FREE(item->contact->home_street);
3418 SAFE_FREE(item->contact->initials); 3551 SAFE_FREE(item->contact->initials);
3419 SAFE_FREE(item->contact->isdn_phone); 3552 SAFE_FREE(item->contact->isdn_phone);
3420 SAFE_FREE(item->contact->job_title); 3553 SAFE_FREE(item->contact->job_title);
3421 SAFE_FREE(item->contact->keyword); 3554 SAFE_FREE(item->contact->keyword);
3422 SAFE_FREE(item->contact->language); 3555 SAFE_FREE(item->contact->language);
3423 SAFE_FREE(item->contact->location); 3556 SAFE_FREE(item->contact->location);
3424 SAFE_FREE(item->contact->manager_name); 3557 SAFE_FREE(item->contact->manager_name);
3425 SAFE_FREE(item->contact->middle_name); 3558 SAFE_FREE(item->contact->middle_name);
3426 SAFE_FREE(item->contact->mileage); 3559 SAFE_FREE(item->contact->mileage);
3427 SAFE_FREE(item->contact->mobile_phone); 3560 SAFE_FREE(item->contact->mobile_phone);
3428 SAFE_FREE(item->contact->nickname); 3561 SAFE_FREE(item->contact->nickname);
3429 SAFE_FREE(item->contact->office_loc); 3562 SAFE_FREE(item->contact->office_loc);
3430 SAFE_FREE(item->contact->org_id); 3563 SAFE_FREE(item->contact->org_id);
3431 SAFE_FREE(item->contact->other_address); 3564 SAFE_FREE(item->contact->other_address);
3432 SAFE_FREE(item->contact->other_city); 3565 SAFE_FREE(item->contact->other_city);
3433 SAFE_FREE(item->contact->other_country); 3566 SAFE_FREE(item->contact->other_country);
3434 SAFE_FREE(item->contact->other_phone); 3567 SAFE_FREE(item->contact->other_phone);
3435 SAFE_FREE(item->contact->other_po_box); 3568 SAFE_FREE(item->contact->other_po_box);
3436 SAFE_FREE(item->contact->other_postal_code); 3569 SAFE_FREE(item->contact->other_postal_code);
3437 SAFE_FREE(item->contact->other_state); 3570 SAFE_FREE(item->contact->other_state);
3438 SAFE_FREE(item->contact->other_street); 3571 SAFE_FREE(item->contact->other_street);
3439 SAFE_FREE(item->contact->pager_phone); 3572 SAFE_FREE(item->contact->pager_phone);
3440 SAFE_FREE(item->contact->personal_homepage); 3573 SAFE_FREE(item->contact->personal_homepage);
3441 SAFE_FREE(item->contact->pref_name); 3574 SAFE_FREE(item->contact->pref_name);
3442 SAFE_FREE(item->contact->primary_fax); 3575 SAFE_FREE(item->contact->primary_fax);
3443 SAFE_FREE(item->contact->primary_phone); 3576 SAFE_FREE(item->contact->primary_phone);
3444 SAFE_FREE(item->contact->profession); 3577 SAFE_FREE(item->contact->profession);
3445 SAFE_FREE(item->contact->radio_phone); 3578 SAFE_FREE(item->contact->radio_phone);
3446 SAFE_FREE(item->contact->spouse_name); 3579 SAFE_FREE(item->contact->spouse_name);
3447 SAFE_FREE(item->contact->suffix); 3580 SAFE_FREE(item->contact->suffix);
3448 SAFE_FREE(item->contact->surname); 3581 SAFE_FREE(item->contact->surname);
3449 SAFE_FREE(item->contact->telex); 3582 SAFE_FREE(item->contact->telex);
3450 SAFE_FREE(item->contact->transmittable_display_name); 3583 SAFE_FREE(item->contact->transmittable_display_name);
3451 SAFE_FREE(item->contact->ttytdd_phone); 3584 SAFE_FREE(item->contact->ttytdd_phone);
3452 SAFE_FREE(item->contact->wedding_anniversary); 3585 SAFE_FREE(item->contact->wedding_anniversary);
3453 free(item->contact); 3586 free(item->contact);
3454 } 3587 }
3455 while (item->attach) { 3588 while (item->attach) {
3456 SAFE_FREE(item->attach->filename1); 3589 SAFE_FREE(item->attach->filename1);
3457 SAFE_FREE(item->attach->filename2); 3590 SAFE_FREE(item->attach->filename2);
3458 SAFE_FREE(item->attach->mimetype); 3591 SAFE_FREE(item->attach->mimetype);
3459 SAFE_FREE(item->attach->data); 3592 SAFE_FREE(item->attach->data);
3460 t = item->attach->next; 3593 t = item->attach->next;
3461 free(item->attach); 3594 free(item->attach);
3462 item->attach = t; 3595 item->attach = t;
3463 } 3596 }
3464 while (item->extra_fields) { 3597 while (item->extra_fields) {
3465 SAFE_FREE(item->extra_fields->field_name); 3598 SAFE_FREE(item->extra_fields->field_name);
3466 SAFE_FREE(item->extra_fields->value); 3599 SAFE_FREE(item->extra_fields->value);
3467 et = item->extra_fields->next; 3600 et = item->extra_fields->next;
3468 free(item->extra_fields); 3601 free(item->extra_fields);
3469 item->extra_fields = et; 3602 item->extra_fields = et;
3470 } 3603 }
3471 if (item->journal) { 3604 if (item->journal) {
3472 SAFE_FREE(item->journal->end); 3605 SAFE_FREE(item->journal->end);
3473 SAFE_FREE(item->journal->start); 3606 SAFE_FREE(item->journal->start);
3474 SAFE_FREE(item->journal->type); 3607 SAFE_FREE(item->journal->type);
3475 free(item->journal); 3608 free(item->journal);
3476 } 3609 }
3477 if (item->appointment) { 3610 if (item->appointment) {
3478 SAFE_FREE(item->appointment->location); 3611 SAFE_FREE(item->appointment->location);
3479 SAFE_FREE(item->appointment->reminder); 3612 SAFE_FREE(item->appointment->reminder);
3480 SAFE_FREE(item->appointment->start); 3613 SAFE_FREE(item->appointment->start);
3481 SAFE_FREE(item->appointment->end); 3614 SAFE_FREE(item->appointment->end);
3482 SAFE_FREE(item->appointment->timezonestring); 3615 SAFE_FREE(item->appointment->timezonestring);
3483 free(item->appointment); 3616 free(item->appointment);
3484 } 3617 }
3485 SAFE_FREE(item->ascii_type); 3618 SAFE_FREE(item->ascii_type);
3486 SAFE_FREE(item->comment); 3619 SAFE_FREE(item->comment);
3487 SAFE_FREE(item->create_date); 3620 SAFE_FREE(item->create_date);
3488 SAFE_FREE(item->file_as); 3621 SAFE_FREE(item->file_as);
3489 SAFE_FREE(item->modify_date); 3622 SAFE_FREE(item->modify_date);
3490 SAFE_FREE(item->outlook_version); 3623 SAFE_FREE(item->outlook_version);
3491 SAFE_FREE(item->record_key); 3624 SAFE_FREE(item->record_key);
3492 free(item); 3625 free(item);
3493 } 3626 }
3494 DEBUG_RET(); 3627 DEBUG_RET();
3495 } 3628 }
3496 3629
3497 3630
3498 /** 3631 /**
3499 * The offset might be zero, in which case we have no data, so return a pair of null pointers. 3632 * The offset might be zero, in which case we have no data, so return a pair of null pointers.
3500 * Or, the offset might end in 0xf, so it is an id2 pointer, in which case we read the id2 block. 3633 * Or, the offset might end in 0xf, so it is an id2 pointer, in which case we read the id2 block.
3501 * Otherwise, the offset>>4 is an index into the table of offsets in the buffer. 3634 * Otherwise, the offset>>4 is an index into the table of offsets in the buffer.
3502 */ 3635 */
3503 int32_t _pst_getBlockOffsetPointer(pst_file *pf, pst_index2_ll *i2_head, unsigned char *buf, int32_t read_size, int32_t i_offset, int32_t offset, pst_block_offset_pointer *p) { 3636 int32_t _pst_getBlockOffsetPointer(pst_file *pf, pst_index2_ll *i2_head, unsigned char *buf, int32_t read_size, int32_t i_offset, int32_t offset, pst_block_offset_pointer *p) {
3504 int32_t size; 3637 int32_t size;
3505 pst_block_offset block_offset; 3638 pst_block_offset block_offset;
3506 DEBUG_ENT("_pst_getBlockOffsetPointer"); 3639 DEBUG_ENT("_pst_getBlockOffsetPointer");
3507 if (p->needfree) free(p->from); 3640 if (p->needfree) free(p->from);
3508 p->from = NULL; 3641 p->from = NULL;
3509 p->needfree = 0; 3642 p->needfree = 0;
3510 if (!offset) { 3643 if (!offset) {
3511 p->from = p->to = NULL; 3644 p->from = p->to = NULL;
3512 } 3645 }
3513 else if ((offset & 0xf) == 0xf) { 3646 else if ((offset & 0xf) == 0xf) {
3514 DEBUG_WARN(("Found id2 %#x value. Will follow it\n", offset)); 3647 DEBUG_WARN(("Found id2 %#x value. Will follow it\n", offset));
3515 size = _pst_ff_getID2block(pf, offset, i2_head, &(p->from)); 3648 size = _pst_ff_getID2block(pf, offset, i2_head, &(p->from));
3516 if (size) { 3649 if (size) {
3517 p->to = p->from + size; 3650 p->to = p->from + size;
3518 p->needfree = 1; 3651 p->needfree = 1;
3519 } 3652 }
3520 else { 3653 else {
3521 p->from = p->to = NULL; 3654 p->from = p->to = NULL;
3522 } 3655 }
3523 } 3656 }
3524 else if (_pst_getBlockOffset(buf, read_size, i_offset, offset, &block_offset)) { 3657 else if (_pst_getBlockOffset(buf, read_size, i_offset, offset, &block_offset)) {
3525 p->from = p->to = NULL; 3658 p->from = p->to = NULL;
3526 } 3659 }
3527 else { 3660 else {
3528 p->from = buf + block_offset.from; 3661 p->from = buf + block_offset.from;
3529 p->to = buf + block_offset.to; 3662 p->to = buf + block_offset.to;
3530 } 3663 }
3531 DEBUG_RET(); 3664 DEBUG_RET();
3532 return (p->from) ? 0 : 1; 3665 return (p->from) ? 0 : 1;
3533 } 3666 }
3534 3667
3535 3668
3536 int32_t _pst_getBlockOffset(unsigned char *buf, int32_t read_size, int32_t i_offset, int32_t offset, pst_block_offset *p) { 3669 int32_t _pst_getBlockOffset(unsigned char *buf, int32_t read_size, int32_t i_offset, int32_t offset, pst_block_offset *p) {
3537 int32_t low = offset & 0xf; 3670 int32_t low = offset & 0xf;
3538 int32_t of1 = offset >> 4; 3671 int32_t of1 = offset >> 4;
3539 DEBUG_ENT("_pst_getBlockOffset"); 3672 DEBUG_ENT("_pst_getBlockOffset");
3540 if (!p || !buf || !i_offset || low || (i_offset+2+of1+sizeof(*p) > read_size)) { 3673 if (!p || !buf || !i_offset || low || (i_offset+2+of1+sizeof(*p) > read_size)) {
3541 DEBUG_WARN(("p is NULL or buf is NULL or offset is 0 or offset has low bits or beyond read size (%p, %p, %#x, %i, %i)\n", p, buf, offset, read_size, i_offset)); 3674 DEBUG_WARN(("p is NULL or buf is NULL or offset is 0 or offset has low bits or beyond read size (%p, %p, %#x, %i, %i)\n", p, buf, offset, read_size, i_offset));
3542 DEBUG_RET(); 3675 DEBUG_RET();
3543 return -1; 3676 return -1;
3544 } 3677 }
3545 memcpy(&(p->from), &(buf[(i_offset+2)+of1]), sizeof(p->from)); 3678 memcpy(&(p->from), &(buf[(i_offset+2)+of1]), sizeof(p->from));
3546 memcpy(&(p->to), &(buf[(i_offset+2)+of1+sizeof(p->from)]), sizeof(p->to)); 3679 memcpy(&(p->to), &(buf[(i_offset+2)+of1+sizeof(p->from)]), sizeof(p->to));
3547 LE16_CPU(p->from); 3680 LE16_CPU(p->from);
3548 LE16_CPU(p->to); 3681 LE16_CPU(p->to);
3549 DEBUG_WARN(("get block offset finds from=%i(%#x), to=%i(%#x)\n", p->from, p->from, p->to, p->to)); 3682 DEBUG_WARN(("get block offset finds from=%i(%#x), to=%i(%#x)\n", p->from, p->from, p->to, p->to));
3550 if (p->from > p->to) { 3683 if (p->from > p->to) {
3551 DEBUG_WARN(("get block offset from > to")); 3684 DEBUG_WARN(("get block offset from > to"));
3552 return -1; 3685 return -1;
3553 } 3686 }
3554 DEBUG_RET(); 3687 DEBUG_RET();
3555 return 0; 3688 return 0;
3556 } 3689 }
3557 3690
3558 3691
3559 pst_index_ll* _pst_getID(pst_file* pf, u_int32_t id) { 3692 pst_index_ll* _pst_getID(pst_file* pf, uint64_t id) {
3560 pst_index_ll *ptr = NULL; 3693 pst_index_ll *ptr = NULL;
3561 DEBUG_ENT("_pst_getID"); 3694 DEBUG_ENT("_pst_getID");
3562 if (id == 0) { 3695 if (id == 0) {
3563 DEBUG_RET(); 3696 DEBUG_RET();
3564 return NULL; 3697 return NULL;
3565 } 3698 }
3566 3699
3567 //if (id & 1) DEBUG_INDEX(("have odd id bit %#x\n", id)); 3700 //if (id & 1) DEBUG_INDEX(("have odd id bit %#x\n", id));
3568 //if (id & 2) DEBUG_INDEX(("have two id bit %#x\n", id)); 3701 //if (id & 2) DEBUG_INDEX(("have two id bit %#x\n", id));
3569 id &= 0xFFFFFFFE; 3702 id -= (id & 1);
3570 3703
3571 DEBUG_INDEX(("Trying to find %#x\n", id)); 3704 DEBUG_INDEX(("Trying to find %#llx\n", id));
3572 if (!ptr) ptr = pf->i_head; 3705 if (!ptr) ptr = pf->i_head;
3573 while (ptr && (ptr->id != id)) { 3706 while (ptr && (ptr->id != id)) {
3574 ptr = ptr->next; 3707 ptr = ptr->next;
3575 } 3708 }
3576 if (ptr) {DEBUG_INDEX(("Found Value %#x\n", id)); } 3709 if (ptr) {DEBUG_INDEX(("Found Value %#x\n", id)); }
3577 else {DEBUG_INDEX(("ERROR: Value %#x not found\n", id)); } 3710 else {DEBUG_INDEX(("ERROR: Value %#x not found\n", id)); }
3578 DEBUG_RET(); 3711 DEBUG_RET();
3579 return ptr; 3712 return ptr;
3580 } 3713 }
3581 3714
3582 3715
3583 pst_index_ll * _pst_getID2(pst_index2_ll *ptr, u_int32_t id) { 3716 pst_index_ll * _pst_getID2(pst_index2_ll *ptr, uint32_t id) {
3584 DEBUG_ENT("_pst_getID2"); 3717 DEBUG_ENT("_pst_getID2");
3585 DEBUG_INDEX(("Head = %p\n", ptr)); 3718 DEBUG_INDEX(("Head = %p\n", ptr));
3586 DEBUG_INDEX(("Trying to find %#x\n", id)); 3719 DEBUG_INDEX(("Trying to find %#x\n", id));
3587 while (ptr && (ptr->id2 != id)) { 3720 while (ptr && (ptr->id2 != id)) {
3588 ptr = ptr->next; 3721 ptr = ptr->next;
3589 } 3722 }
3590 if (ptr) { 3723 if (ptr) {
3591 if (ptr->id) {DEBUG_INDEX(("Found value %#x\n", ptr->id->id)); } 3724 if (ptr->id) {DEBUG_INDEX(("Found value %#x\n", ptr->id->id)); }
3592 else {DEBUG_INDEX(("Found value, though it is NULL!\n"));} 3725 else {DEBUG_INDEX(("Found value, though it is NULL!\n"));}
3593 DEBUG_RET(); 3726 DEBUG_RET();
3594 return ptr->id; 3727 return ptr->id;
3595 } 3728 }
3596 DEBUG_INDEX(("ERROR Not Found\n")); 3729 DEBUG_INDEX(("ERROR Not Found\n"));
3597 DEBUG_RET(); 3730 DEBUG_RET();
3598 return NULL; 3731 return NULL;
3599 } 3732 }
3600 3733
3601 3734
3602 /** 3735 /**
3603 * find the id in the descriptor tree rooted at pf->d_head 3736 * find the id in the descriptor tree rooted at pf->d_head
3604 * 3737 *
3605 * @param pf global pst file pointer 3738 * @param pf global pst file pointer
3606 * @param id the id we are looking for 3739 * @param id the id we are looking for
3607 * 3740 *
3608 * @return pointer to the pst_desc_ll node in the descriptor tree 3741 * @return pointer to the pst_desc_ll node in the descriptor tree
3609 */ 3742 */
3610 pst_desc_ll* _pst_getDptr(pst_file *pf, u_int32_t id) { 3743 pst_desc_ll* _pst_getDptr(pst_file *pf, uint32_t id) {
3611 pst_desc_ll *ptr = pf->d_head; 3744 pst_desc_ll *ptr = pf->d_head;
3612 DEBUG_ENT("_pst_getDptr"); 3745 DEBUG_ENT("_pst_getDptr");
3613 while (ptr && (ptr->id != id)) { 3746 while (ptr && (ptr->id != id)) {
3614 if (ptr->child) { 3747 if (ptr->child) {
3615 ptr = ptr->child; 3748 ptr = ptr->child;
3616 continue; 3749 continue;
3617 } 3750 }
3618 while (!ptr->next && ptr->parent) { 3751 while (!ptr->next && ptr->parent) {
3619 ptr = ptr->parent; 3752 ptr = ptr->parent;
3620 } 3753 }
3621 ptr = ptr->next; 3754 ptr = ptr->next;
3622 } 3755 }
3623 DEBUG_RET(); 3756 DEBUG_RET();
3624 return ptr; // will be NULL or record we are looking for 3757 return ptr; // will be NULL or record we are looking for
3625 } 3758 }
3626 3759
3627 3760
3628 int32_t _pst_printDptr(pst_file *pf) { 3761 int32_t _pst_printDptr(pst_file *pf) {
3629 pst_desc_ll *ptr = pf->d_head; 3762 pst_desc_ll *ptr = pf->d_head;
3630 int32_t depth = 0; 3763 int32_t depth = 0;
3631 char spaces[100]; 3764 char spaces[100];
3632 DEBUG_ENT("_pst_printDptr"); 3765 DEBUG_ENT("_pst_printDptr");
3633 memset(spaces, ' ', 99); 3766 memset(spaces, ' ', 99);
3634 spaces[99] = '\0'; 3767 spaces[99] = '\0';
3635 while (ptr) { 3768 while (ptr) {
3636 DEBUG_INDEX(("%s%#x [%i] desc=%#x, list=%#x\n", &(spaces[(99-depth<0?0:99-depth)]), ptr->id, ptr->no_child, 3769 DEBUG_INDEX(("%s%#x [%i] desc=%#x, list=%#x\n", &(spaces[(99-depth<0?0:99-depth)]), ptr->id, ptr->no_child,
3637 (ptr->desc==NULL?0:ptr->desc->id), 3770 (ptr->desc==NULL?0:ptr->desc->id),
3638 (ptr->list_index==NULL?0:ptr->list_index->id))); 3771 (ptr->list_index==NULL?0:ptr->list_index->id)));
3639 if (ptr->child) { 3772 if (ptr->child) {
3640 depth++; 3773 depth++;
3641 ptr = ptr->child; 3774 ptr = ptr->child;
3642 continue; 3775 continue;
3643 } 3776 }
3644 while (!ptr->next && ptr->parent) { 3777 while (!ptr->next && ptr->parent) {
3645 depth--; 3778 depth--;
3646 ptr = ptr->parent; 3779 ptr = ptr->parent;
3647 } 3780 }
3648 ptr = ptr->next; 3781 ptr = ptr->next;
3649 } 3782 }
3650 DEBUG_RET(); 3783 DEBUG_RET();
3651 return 0; 3784 return 0;
3652 } 3785 }
3653 3786
3654 3787
3655 int32_t _pst_printIDptr(pst_file* pf) { 3788 int32_t _pst_printIDptr(pst_file* pf) {
3656 pst_index_ll *ptr = pf->i_head; 3789 pst_index_ll *ptr = pf->i_head;
3657 DEBUG_ENT("_pst_printIDptr"); 3790 DEBUG_ENT("_pst_printIDptr");
3658 while (ptr) { 3791 while (ptr) {
3659 DEBUG_INDEX(("%#x offset=%#x size=%#x\n", ptr->id, ptr->offset, ptr->size)); 3792 DEBUG_INDEX(("%#x offset=%#x size=%#x\n", ptr->id, ptr->offset, ptr->size));
3660 ptr = ptr->next; 3793 ptr = ptr->next;
3661 } 3794 }
3662 DEBUG_RET(); 3795 DEBUG_RET();
3663 return 0; 3796 return 0;
3664 } 3797 }
3665 3798
3666 3799
3667 int32_t _pst_printID2ptr(pst_index2_ll *ptr) { 3800 int32_t _pst_printID2ptr(pst_index2_ll *ptr) {
3668 DEBUG_ENT("_pst_printID2ptr"); 3801 DEBUG_ENT("_pst_printID2ptr");
3669 while (ptr) { 3802 while (ptr) {
3670 DEBUG_INDEX(("%#x id=%#x\n", ptr->id2, (ptr->id!=NULL?ptr->id->id:0))); 3803 DEBUG_INDEX(("%#x id=%#x\n", ptr->id2, (ptr->id!=NULL?ptr->id->id:0)));
3671 ptr = ptr->next; 3804 ptr = ptr->next;
3672 } 3805 }
3673 DEBUG_RET(); 3806 DEBUG_RET();
3674 return 0; 3807 return 0;
3675 } 3808 }
3676 3809
3677 3810
3678 size_t _pst_read_block(FILE *fp, int32_t offset, void **buf) { 3811 size_t _pst_read_block(FILE *fp, off_t offset, void **buf) {
3679 size_t size; 3812 int16_t size16;
3680 int32_t fpos; 3813 size_t size;
3681 DEBUG_ENT("_pst_read_block"); 3814 off_t fpos;
3682 DEBUG_READ(("Reading block from %#x\n", offset)); 3815 DEBUG_ENT("_pst_read_block");
3683 fpos = ftell(fp); 3816 DEBUG_READ(("Reading block from %#x\n", offset));
3684 fseek(fp, offset, SEEK_SET); 3817 fpos = ftell(fp);
3685 fread(&size, sizeof(int16_t), 1, fp); 3818 fseek(fp, offset, SEEK_SET);
3686 fseek(fp, offset, SEEK_SET); 3819 fread(&size16, sizeof(int16_t), 1, fp);
3687 DEBUG_READ(("Allocating %i bytes\n", size)); 3820 LE16_CPU(size16);
3688 if (*buf) { 3821 size = size16;
3689 DEBUG_READ(("Freeing old memory\n")); 3822 fseek(fp, offset, SEEK_SET);
3690 free(*buf); 3823 DEBUG_READ(("Allocating %i bytes\n", size));
3691 } 3824 if (*buf) {
3692 *buf = (void*)xmalloc(size); 3825 DEBUG_READ(("Freeing old memory\n"));
3693 size = fread(*buf, 1, size, fp); 3826 free(*buf);
3694 fseek(fp, fpos, SEEK_SET); 3827 }
3695 DEBUG_RET(); 3828 *buf = (void*)xmalloc(size);
3696 return size; 3829 size = fread(*buf, 1, size, fp);
3830 fseek(fp, fpos, SEEK_SET);
3831 DEBUG_RET();
3832 return size;
3697 } 3833 }
3698 3834
3699 3835
3700 // when the first byte of the block being read is 01, then we can assume 3836 // when the first byte of the block being read is 01, then we can assume
3701 // that it is a list of further ids to read and we will follow those ids 3837 // that it is a list of further ids to read and we will follow those ids
3702 // recursively calling this function until we have all the data 3838 // recursively calling this function until we have all the data
3703 // we could do decryption of the encrypted PST files here 3839 // we could do decryption of the encrypted PST files here
3704 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) { 3840 size_t _pst_read_block_size(pst_file *pf, off_t offset, size_t size, char **buf, int32_t do_enc, unsigned char is_index) {
3705 u_int32_t fpos, x; 3841 off_t fpos;
3706 int16_t count, y; 3842 int32_t x;
3707 char *buf2 = NULL, *buf3 = NULL; 3843 int16_t count, y;
3708 unsigned char fdepth; 3844 char *buf2 = NULL, *buf3 = NULL;
3709 pst_index_ll *ptr = NULL; 3845 unsigned char fdepth;
3710 size_t rsize, z; 3846 pst_index_ll *ptr = NULL;
3711 3847 size_t rsize, z;
3712 DEBUG_ENT("_pst_read_block_size"); 3848
3713 DEBUG_READ(("Reading block from %#x, %i bytes\n", offset, size)); 3849 DEBUG_ENT("_pst_read_block_size");
3714 3850 DEBUG_READ(("Reading block from %#x, %i bytes\n", offset, size));
3715 fpos = ftell(pf->fp); 3851
3716 fseek(pf->fp, offset, SEEK_SET); 3852 fpos = ftell(pf->fp);
3717 if (*buf) { 3853 fseek(pf->fp, offset, SEEK_SET);
3718 DEBUG_READ(("Freeing old memory\n")); 3854 if (*buf) {
3719 free(*buf); 3855 DEBUG_READ(("Freeing old memory\n"));
3720 } 3856 free(*buf);
3721 3857 }
3722 *buf = (void*) xmalloc(size+1); //plus one so that we can NUL terminate it later 3858
3723 rsize = fread(*buf, 1, size, pf->fp); 3859 *buf = (void*) xmalloc(size+1); //plus one so that we can NUL terminate it later
3724 if (rsize != size) { 3860 rsize = fread(*buf, 1, size, pf->fp);
3725 DEBUG_WARN(("Didn't read all that I could. fread returned less [%i instead of %i]\n", rsize, size)); 3861 if (rsize != size) {
3726 if (feof(pf->fp)) { 3862 DEBUG_WARN(("Didn't read all that I could. fread returned less [%i instead of %i]\n", rsize, size));
3727 DEBUG_WARN(("We tried to read past the end of the file at [offset %#x, size %#x]\n", offset, size)); 3863 if (feof(pf->fp)) {
3728 } else if (ferror(pf->fp)) { 3864 DEBUG_WARN(("We tried to read past the end of the file at [offset %#x, size %#x]\n", offset, size));
3729 DEBUG_WARN(("Error is set on file stream.\n")); 3865 } else if (ferror(pf->fp)) {
3730 } else { 3866 DEBUG_WARN(("Error is set on file stream.\n"));
3731 DEBUG_WARN(("I can't tell why it failed\n")); 3867 } else {
3732 } 3868 DEBUG_WARN(("I can't tell why it failed\n"));
3733 size = rsize; 3869 }
3734 } 3870 size = rsize;
3735 3871 }
3736 // DEBUG_HEXDUMP(*buf, size); 3872
3737 3873 // DEBUG_HEXDUMP(*buf, size);
3738 /* if (is_index) { 3874
3739 DEBUG_READ(("_pst_read_block_size: ODD_BLOCK should be here\n")); 3875 /* if (is_index) {
3740 DEBUG_READ(("\t: byte 0-1: %#x %#x\n", (*buf)[0], (*buf)[1])); 3876 DEBUG_READ(("_pst_read_block_size: ODD_BLOCK should be here\n"));
3741 }*/ 3877 DEBUG_READ(("\t: byte 0-1: %#x %#x\n", (*buf)[0], (*buf)[1]));
3742 3878 }*/
3743 if ((*buf)[0] == 0x01 && (*buf)[1] != 0x00 && is_index) { 3879
3744 //don't do this recursion if we should be at a leaf node 3880 if ((*buf)[0] == 0x01 && (*buf)[1] != 0x00 && is_index) {
3745 memcpy(&count, &((*buf)[2]), sizeof(int16_t)); 3881 //don't do this recursion if we should be at a leaf node
3746 LE16_CPU(count); 3882 memcpy(&count, &((*buf)[2]), sizeof(int16_t));
3747 memcpy(&fdepth, &((*buf)[1]), sizeof(fdepth)); 3883 LE16_CPU(count);
3748 DEBUG_READ(("Seen indexes to blocks. Depth is %i\n", fdepth)); 3884 memcpy(&fdepth, &((*buf)[1]), sizeof(fdepth));
3749 // do fancy stuff! :) 3885 DEBUG_READ(("Seen indexes to blocks. Depth is %i\n", fdepth));
3750 DEBUG_READ(("There are %i ids\n", count)); 3886 // do fancy stuff! :)
3751 // if first 2 blocks are 01 01 then index to blocks 3887 DEBUG_READ(("There are %i ids\n", count));
3752 size = 0; 3888 // if first 2 blocks are 01 01 then index to blocks
3753 y = 0; 3889 size = 0;
3754 while (y < count) { 3890 y = 0;
3755 memcpy(&x, &(*buf)[0x08+(y*4)], sizeof(int32_t)); 3891 while (y < count) {
3756 LE32_CPU(x); 3892 memcpy(&x, &(*buf)[0x08+(y*4)], sizeof(int32_t));
3757 if ((ptr = _pst_getID(pf, x)) == NULL) { 3893 LE32_CPU(x);
3758 WARN(("Error. Cannot find ID [%#x] during multi-block read\n", x)); 3894 if ((ptr = _pst_getID(pf, x)) == NULL) {
3759 buf3 = (char*) realloc(buf3, size+1); 3895 WARN(("Error. Cannot find ID [%#x] during multi-block read\n", x));
3760 buf3[size] = '\0'; 3896 buf3 = (char*) realloc(buf3, size+1);
3761 *buf = buf3; 3897 buf3[size] = '\0';
3762 fseek(pf->fp, fpos, SEEK_SET); 3898 *buf = buf3;
3763 DEBUG_RET(); 3899 fseek(pf->fp, fpos, SEEK_SET);
3764 return size; 3900 DEBUG_RET();
3765 } 3901 return size;
3766 if ((z = _pst_read_block_size(pf, ptr->offset, ptr->size, &buf2, do_enc, fdepth-1)) < ptr->size) { 3902 }
3767 buf3 = (char*) realloc(buf3, size+1); 3903 if ((z = _pst_read_block_size(pf, ptr->offset, ptr->size, &buf2, do_enc, fdepth-1)) < ptr->size) {
3768 buf3[size] = '\0'; 3904 buf3 = (char*) realloc(buf3, size+1);
3769 *buf = buf3; 3905 buf3[size] = '\0';
3770 fseek(pf->fp, fpos, SEEK_SET); 3906 *buf = buf3;
3771 DEBUG_RET(); 3907 fseek(pf->fp, fpos, SEEK_SET);
3772 return size; 3908 DEBUG_RET();
3773 } 3909 return size;
3774 DEBUG_READ(("Melding newley retrieved block with bigger one. New size is %i\n", size+z)); 3910 }
3775 buf3 = (char*) realloc(buf3, size+z+1); //plus one so that we can null terminate it later 3911 DEBUG_READ(("Melding newley retrieved block with bigger one. New size is %i\n", size+z));
3776 DEBUG_READ(("Doing copy. Start pos is %i, length is %i\n", size, z)); 3912 buf3 = (char*) realloc(buf3, size+z+1); //plus one so that we can null terminate it later
3777 memcpy(&(buf3[size]), buf2, z); 3913 DEBUG_READ(("Doing copy. Start pos is %i, length is %i\n", size, z));
3778 size += z; 3914 memcpy(&(buf3[size]), buf2, z);
3779 y++; 3915 size += z;
3780 } 3916 y++;
3781 free(*buf); 3917 }
3782 if (buf2) free(buf2); 3918 free(*buf);
3783 if (!buf3) { 3919 if (buf2) free(buf2);
3784 // this can happen if count == 0. We should create an empty buffer so we don't 3920 if (!buf3) {
3785 // confuse any clients 3921 // this can happen if count == 0. We should create an empty buffer so we don't
3786 buf3 = (char*) xmalloc(1); 3922 // confuse any clients
3787 } 3923 buf3 = (char*) xmalloc(1);
3788 *buf = buf3; 3924 }
3789 } else if (do_enc && pf->encryption) 3925 *buf = buf3;
3790 _pst_decrypt(*buf, size, pf->encryption); 3926 } else if (do_enc && pf->encryption)
3791 3927 _pst_decrypt(*buf, size, pf->encryption);
3792 (*buf)[size] = '\0'; //should be byte after last one read 3928
3793 fseek(pf->fp, fpos, SEEK_SET); 3929 (*buf)[size] = '\0'; //should be byte after last one read
3794 DEBUG_RET(); 3930 fseek(pf->fp, fpos, SEEK_SET);
3795 return size; 3931 DEBUG_RET();
3932 return size;
3796 } 3933 }
3797 3934
3798 3935
3799 int32_t _pst_decrypt(unsigned char *buf, size_t size, int32_t type) { 3936 int32_t _pst_decrypt(unsigned char *buf, size_t size, int32_t type) {
3800 size_t x = 0; 3937 size_t x = 0;
3801 unsigned char y; 3938 unsigned char y;
3802 DEBUG_ENT("_pst_decrypt"); 3939 DEBUG_ENT("_pst_decrypt");
3803 if (!buf) { 3940 if (!buf) {
3804 DEBUG_RET(); 3941 DEBUG_RET();
3805 return -1; 3942 return -1;
3806 } 3943 }
3807 3944
3808 if (type == PST_COMP_ENCRYPT) { 3945 if (type == PST_COMP_ENCRYPT) {
3809 x = 0; 3946 x = 0;
3810 while (x < size) { 3947 while (x < size) {
3811 y = buf[x]; 3948 y = buf[x];
3812 DEBUG_DECRYPT(("Transposing %#hhx to %#hhx [%#x]\n", buf[x], comp_enc[y], y)); 3949 DEBUG_DECRYPT(("Transposing %#hhx to %#hhx [%#x]\n", buf[x], comp_enc[y], y));
3813 buf[x] = comp_enc[y]; // transpose from encrypt array 3950 buf[x] = comp_enc[y]; // transpose from encrypt array
3814 x++; 3951 x++;
3815 } 3952 }
3816 } else { 3953 } else {
3817 WARN(("Unknown encryption: %i. Cannot decrypt\n", type)); 3954 WARN(("Unknown encryption: %i. Cannot decrypt\n", type));
3818 DEBUG_RET(); 3955 DEBUG_RET();
3819 return -1; 3956 return -1;
3820 } 3957 }
3821 DEBUG_RET(); 3958 DEBUG_RET();
3822 return 0; 3959 return 0;
3823 } 3960 }
3824 3961
3825 3962
3826 int32_t _pst_getAtPos(FILE *fp, int32_t pos, void* buf, u_int32_t size) { 3963 int64_t _getIntAt(char *buf) {
3827 DEBUG_ENT("_pst_getAtPos"); 3964 int64_t buf64;
3828 if (fseek(fp, pos, SEEK_SET) == -1) { 3965 int32_t buf32;
3829 DEBUG_RET(); 3966 if (do_read64) {
3830 return 1; 3967 memcpy(&buf64, buf, sizeof(buf64));
3831 } 3968 LE64_CPU(buf64);
3832 3969 return buf64;
3833 if (fread(buf, 1, size, fp) < size) { 3970 }
3834 DEBUG_RET(); 3971 else {
3835 return 2; 3972 memcpy(&buf32, buf, sizeof(buf32));
3836 } 3973 LE32_CPU(buf32);
3837 DEBUG_RET(); 3974 return buf32;
3838 return 0; 3975 }
3839 } 3976 }
3840 3977
3841 3978
3842 int32_t _pst_get (FILE *fp, void *buf, u_int32_t size) { 3979 int64_t _pst_getIntAtPos(FILE *fp, off_t pos ) {
3843 DEBUG_ENT("_pst_get"); 3980 int64_t buf64;
3844 if (fread(buf, 1, size, fp) < size) { 3981 int32_t buf32;
3845 DEBUG_RET(); 3982 if (do_read64) {
3846 return 1; 3983 _pst_getAtPos(fp, pos, &buf64, sizeof(buf64));
3847 } 3984 LE64_CPU(buf64);
3848 DEBUG_RET(); 3985 return buf64;
3849 return 0; 3986 }
3850 } 3987 else {
3851 3988 _pst_getAtPos(fp, pos, &buf32, sizeof(buf32));
3852 3989 LE32_CPU(buf32);
3853 size_t _pst_ff_getIDblock_dec(pst_file *pf, u_int32_t id, unsigned char **b) { 3990 return buf32;
3854 size_t r; 3991 }
3855 DEBUG_ENT("_pst_ff_getIDblock_dec"); 3992 }
3856 DEBUG_INDEX(("for id %#x\n", id)); 3993
3857 r = _pst_ff_getIDblock(pf, id, b); 3994
3858 int noenc = (id & 2); // disable encryption 3995 int32_t _pst_getAtPos(FILE *fp, off_t pos, void* buf, uint32_t size) {
3859 if ((pf->encryption) & !(noenc)) { 3996 DEBUG_ENT("_pst_getAtPos");
3860 _pst_decrypt(*b, r, pf->encryption); 3997 if (fseek(fp, pos, SEEK_SET) == -1) {
3861 } 3998 DEBUG_RET();
3862 DEBUG_HEXDUMPC(*b, r, 16); 3999 return 1;
3863 DEBUG_RET(); 4000 }
3864 return r; 4001 if (fread(buf, 1, size, fp) < size) {
3865 } 4002 DEBUG_RET();
3866 4003 return 2;
3867 4004 }
3868 size_t _pst_ff_getIDblock(pst_file *pf, u_int32_t id, unsigned char** b) { 4005 DEBUG_RET();
3869 pst_index_ll *rec; 4006 return 0;
3870 size_t rsize = 0;//, re_size=0; 4007 }
3871 DEBUG_ENT("_pst_ff_getIDblock"); 4008
3872 if ((rec = _pst_getID(pf, id)) == NULL) { 4009
3873 DEBUG_INDEX(("Cannot find ID %#x\n", id)); 4010 int32_t _pst_get (FILE *fp, void *buf, uint32_t size) {
3874 DEBUG_RET(); 4011 DEBUG_ENT("_pst_get");
3875 return 0; 4012 if (fread(buf, 1, size, fp) < size) {
3876 } 4013 DEBUG_RET();
3877 fseek(pf->fp, rec->offset, SEEK_SET); 4014 return 1;
3878 if (*b) { 4015 }
3879 DEBUG_INDEX(("freeing old memory in b\n")); 4016 DEBUG_RET();
3880 free(*b); 4017 return 0;
3881 } 4018 }
3882 4019
3883 DEBUG_INDEX(("id = %#x, record size = %#x, offset = %#x\n", id, rec->size, rec->offset)); 4020
3884 *b = (char*) xmalloc(rec->size+1); 4021 size_t _pst_ff_getIDblock_dec(pst_file *pf, uint32_t id, unsigned char **b) {
3885 rsize = fread(*b, 1, rec->size, pf->fp); 4022 size_t r;
3886 if (rsize != rec->size) { 4023 DEBUG_ENT("_pst_ff_getIDblock_dec");
3887 DEBUG_WARN(("Didn't read all the size. fread returned less [%i instead of %i]\n", rsize, rec->size)); 4024 DEBUG_INDEX(("for id %#x\n", id));
3888 if (feof(pf->fp)) { 4025 r = _pst_ff_getIDblock(pf, id, b);
3889 DEBUG_WARN(("We tried to read past the end of the file [offset %#x, size %#x]\n", rec->offset, rec->size)); 4026 int noenc = (id & 2); // disable encryption
3890 } else if (ferror(pf->fp)) { 4027 if ((pf->encryption) & !(noenc)) {
3891 DEBUG_WARN(("Some error occured on the file stream\n")); 4028 _pst_decrypt(*b, r, pf->encryption);
3892 } else { 4029 }
3893 DEBUG_WARN(("No error has been set on the file stream\n")); 4030 DEBUG_HEXDUMPC(*b, r, 16);
3894 } 4031 DEBUG_RET();
3895 } 4032 return r;
3896 DEBUG_RET(); 4033 }
3897 return rsize; 4034
4035
4036 size_t _pst_ff_getIDblock(pst_file *pf, uint32_t id, unsigned char** b) {
4037 pst_index_ll *rec;
4038 size_t rsize = 0;//, re_size=0;
4039 DEBUG_ENT("_pst_ff_getIDblock");
4040 if ((rec = _pst_getID(pf, id)) == NULL) {
4041 DEBUG_INDEX(("Cannot find ID %#x\n", id));
4042 DEBUG_RET();
4043 return 0;
4044 }
4045 fseek(pf->fp, rec->offset, SEEK_SET);
4046 if (*b) {
4047 DEBUG_INDEX(("freeing old memory in b\n"));
4048 free(*b);
4049 }
4050
4051 DEBUG_INDEX(("id = %#x, record size = %#x, offset = %#x\n", id, rec->size, rec->offset));
4052 *b = (char*) xmalloc(rec->size+1);
4053 rsize = fread(*b, 1, rec->size, pf->fp);
4054 if (rsize != rec->size) {
4055 DEBUG_WARN(("Didn't read all the size. fread returned less [%i instead of %i]\n", rsize, rec->size));
4056 if (feof(pf->fp)) {
4057 DEBUG_WARN(("We tried to read past the end of the file [offset %#x, size %#x]\n", rec->offset, rec->size));
4058 } else if (ferror(pf->fp)) {
4059 DEBUG_WARN(("Some error occured on the file stream\n"));
4060 } else {
4061 DEBUG_WARN(("No error has been set on the file stream\n"));
4062 }
4063 }
4064 DEBUG_RET();
4065 return rsize;
3898 } 4066 }
3899 4067
3900 4068
3901 #define PST_PTR_BLOCK_SIZE 0x120 4069 #define PST_PTR_BLOCK_SIZE 0x120
3902 size_t _pst_ff_getID2block(pst_file *pf, u_int32_t id2, pst_index2_ll *id2_head, unsigned char** buf) { 4070 size_t _pst_ff_getID2block(pst_file *pf, uint32_t id2, pst_index2_ll *id2_head, unsigned char** buf) {
3903 pst_index_ll* ptr; 4071 pst_index_ll* ptr;
3904 // size_t ret; 4072 // size_t ret;
3905 struct holder h = {buf, NULL, 0, "", 0}; 4073 struct holder h = {buf, NULL, 0, "", 0};
3906 DEBUG_ENT("_pst_ff_getID2block"); 4074 DEBUG_ENT("_pst_ff_getID2block");
3907 ptr = _pst_getID2(id2_head, id2); 4075 ptr = _pst_getID2(id2_head, id2);
3908 4076
3909 if (!ptr) { 4077 if (!ptr) {
3910 DEBUG_INDEX(("Cannot find id2 value %#x\n", id2)); 4078 DEBUG_INDEX(("Cannot find id2 value %#x\n", id2));
3911 DEBUG_RET(); 4079 DEBUG_RET();
3912 return 0; 4080 return 0;
3913 } 4081 }
3914 DEBUG_RET(); 4082 DEBUG_RET();
3915 return _pst_ff_getID2data(pf, ptr, &h); 4083 return _pst_ff_getID2data(pf, ptr, &h);
3916 } 4084 }
3917 4085
3918 4086
3919 size_t _pst_ff_getID2data(pst_file *pf, pst_index_ll *ptr, struct holder *h) { 4087 size_t _pst_ff_getID2data(pst_file *pf, pst_index_ll *ptr, struct holder *h) {
3920 int32_t ret; 4088 int32_t ret;
3921 unsigned char *b = NULL, *t; 4089 unsigned char *b = NULL, *t;
3922 DEBUG_ENT("_pst_ff_getID2data"); 4090 DEBUG_ENT("_pst_ff_getID2data");
3923 if (!(ptr->id & 0x02)) { 4091 if (!(ptr->id & 0x02)) {
3924 ret = _pst_ff_getIDblock_dec(pf, ptr->id, &b); 4092 ret = _pst_ff_getIDblock_dec(pf, ptr->id, &b);
3925 if (h->buf) { 4093 if (h->buf) {
3926 *(h->buf) = b; 4094 *(h->buf) = b;
3927 } else if ((h->base64 == 1) && h->fp) { 4095 } else if ((h->base64 == 1) && h->fp) {
3928 t = base64_encode(b, ret); 4096 t = base64_encode(b, ret);
3929 if (t) { 4097 if (t) {
3930 pst_fwrite(t, 1, strlen(t), h->fp); 4098 pst_fwrite(t, 1, strlen(t), h->fp);
3931 free(t); // caught by valgrind 4099 free(t); // caught by valgrind
3932 } 4100 }
3933 free(b); 4101 free(b);
3934 } else if (h->fp) { 4102 } else if (h->fp) {
3935 pst_fwrite(b, 1, ret, h->fp); 4103 pst_fwrite(b, 1, ret, h->fp);
3936 free(b); 4104 free(b);
3937 } 4105 }
3938 } else { 4106 } else {
3939 // here we will assume it is a block that points to others 4107 // here we will assume it is a block that points to others
3940 DEBUG_READ(("Assuming it is a multi-block record because of it's id\n")); 4108 DEBUG_READ(("Assuming it is a multi-block record because of it's id\n"));
3941 ret = _pst_ff_compile_ID(pf, ptr->id, h, 0); 4109 ret = _pst_ff_compile_ID(pf, ptr->id, h, 0);
3942 } 4110 }
3943 if (h->buf && *h->buf) 4111 if (h->buf && *h->buf)
3944 (*(h->buf))[ret]='\0'; 4112 (*(h->buf))[ret]='\0';
3945 DEBUG_RET(); 4113 DEBUG_RET();
3946 return ret; 4114 return ret;
3947 } 4115 }
3948 4116
3949 4117
3950 size_t _pst_ff_compile_ID(pst_file *pf, u_int32_t id, struct holder *h, int32_t size) { 4118 size_t _pst_ff_compile_ID(pst_file *pf, uint32_t id, struct holder *h, int32_t size) {
3951 size_t z, a; 4119 size_t z, a;
3952 u_int16_t count, y; 4120 uint16_t count, y;
3953 u_int32_t x, b; 4121 uint32_t x, b;
3954 unsigned char * buf3 = NULL, *buf2 = NULL, *t; 4122 unsigned char * buf3 = NULL, *buf2 = NULL, *t;
3955 unsigned char fdepth; 4123 unsigned char fdepth;
3956 4124
3957 DEBUG_ENT("_pst_ff_compile_ID"); 4125 DEBUG_ENT("_pst_ff_compile_ID");
3958 a = _pst_ff_getIDblock(pf, id, &buf3); 4126 a = _pst_ff_getIDblock(pf, id, &buf3);
3959 if (!a) { 4127 if (!a) {
3960 if (buf3) free(buf3); 4128 if (buf3) free(buf3);
3961 return 0; 4129 return 0;
3962 } 4130 }
3963 if ((buf3[0] != 0x1)) { // if bit 8 is set) { 4131 if ((buf3[0] != 0x1)) { // if bit 8 is set) {
3964 // if ((buf3)[0] != 0x1 && (buf3)[1] > 4) { 4132 // if ((buf3)[0] != 0x1 && (buf3)[1] > 4) {
3965 DEBUG_WARN(("WARNING: buffer doesn't start with 0x1, but I expected it to or doesn't have it's two-bit set!\n")); 4133 DEBUG_WARN(("WARNING: buffer doesn't start with 0x1, but I expected it to or doesn't have it's two-bit set!\n"));
3966 DEBUG_WARN(("Treating as normal buffer\n")); 4134 DEBUG_WARN(("Treating as normal buffer\n"));
3967 if (pf->encryption) _pst_decrypt(buf3, a, pf->encryption); 4135 if (pf->encryption) _pst_decrypt(buf3, a, pf->encryption);
3968 if (h->buf) 4136 if (h->buf)
3969 *(h->buf) = buf3; 4137 *(h->buf) = buf3;
3970 else if (h->base64 == 1 && h->fp) { 4138 else if (h->base64 == 1 && h->fp) {
3971 t = base64_encode(buf3, a); 4139 t = base64_encode(buf3, a);
3972 if (t) { 4140 if (t) {
3973 pst_fwrite(t, 1, strlen(t), h->fp); 4141 pst_fwrite(t, 1, strlen(t), h->fp);
3974 free(t); // caught by valgrind 4142 free(t); // caught by valgrind
3975 } 4143 }
3976 free(buf3); 4144 free(buf3);
3977 } else if (h->fp) { 4145 } else if (h->fp) {
3978 pst_fwrite(buf3, 1, a, h->fp); 4146 pst_fwrite(buf3, 1, a, h->fp);
3979 free(buf3); 4147 free(buf3);
3980 } 4148 }
3981 DEBUG_RET(); 4149 DEBUG_RET();
3982 return a; 4150 return a;
3983 } 4151 }
3984 memcpy (&count, &(buf3[2]), sizeof(int16_t)); 4152 memcpy (&count, &(buf3[2]), sizeof(int16_t));
3985 LE16_CPU(count); 4153 LE16_CPU(count);
3986 memcpy (&fdepth, &(buf3[1]), sizeof(char)); 4154 memcpy (&fdepth, &(buf3[1]), sizeof(char));
3987 DEBUG_READ(("Seen index to blocks. Depth is %i\n", fdepth)); 4155 DEBUG_READ(("Seen index to blocks. Depth is %i\n", fdepth));
3988 DEBUG_READ(("There are %i ids here\n", count)); 4156 DEBUG_READ(("There are %i ids here\n", count));
3989 4157
3990 y = 0; 4158 y = 0;
3991 while (y < count) { 4159 while (y < count) {
3992 memcpy(&x, &buf3[0x08+(y*4)], sizeof(int32_t)); 4160 memcpy(&x, &buf3[0x08+(y*4)], sizeof(int32_t));
3993 LE32_CPU(x); 4161 LE32_CPU(x);
3994 if (fdepth == 0x1) { 4162 if (fdepth == 0x1) {
3995 if ((z = _pst_ff_getIDblock(pf, x, &buf2)) == 0) { 4163 if ((z = _pst_ff_getIDblock(pf, x, &buf2)) == 0) {
3996 DEBUG_WARN(("call to getIDblock returned zero %i\n", z)); 4164 DEBUG_WARN(("call to getIDblock returned zero %i\n", z));
3997 if (buf2) free(buf2); 4165 if (buf2) free(buf2);
3998 free(buf3); 4166 free(buf3);
3999 return z; 4167 return z;
4000 } 4168 }
4001 if (pf->encryption) _pst_decrypt(buf2, z, pf->encryption); 4169 if (pf->encryption) _pst_decrypt(buf2, z, pf->encryption);
4002 if (h->buf) { 4170 if (h->buf) {
4003 *(h->buf) = realloc(*(h->buf), size+z+1); 4171 *(h->buf) = realloc(*(h->buf), size+z+1);
4004 DEBUG_READ(("appending read data of size %i onto main buffer from pos %i\n", z, size)); 4172 DEBUG_READ(("appending read data of size %i onto main buffer from pos %i\n", z, size));
4005 memcpy(&((*(h->buf))[size]), buf2, z); 4173 memcpy(&((*(h->buf))[size]), buf2, z);
4006 } 4174 }
4007 else if ((h->base64 == 1) && h->fp) { 4175 else if ((h->base64 == 1) && h->fp) {
4008 // include any byte left over from the last one encoding 4176 // include any byte left over from the last one encoding
4009 buf2 = (char*)realloc(buf2, z+h->base64_extra); 4177 buf2 = (char*)realloc(buf2, z+h->base64_extra);
4010 memmove(buf2+h->base64_extra, buf2, z); 4178 memmove(buf2+h->base64_extra, buf2, z);
4011 memcpy(buf2, h->base64_extra_chars, h->base64_extra); 4179 memcpy(buf2, h->base64_extra_chars, h->base64_extra);
4012 z+= h->base64_extra; 4180 z+= h->base64_extra;
4013 4181
4014 b = z % 3; // find out how many bytes will be left over after the encoding. 4182 b = z % 3; // find out how many bytes will be left over after the encoding.
4015 // and save them 4183 // and save them
4016 memcpy(h->base64_extra_chars, &(buf2[z-b]), b); 4184 memcpy(h->base64_extra_chars, &(buf2[z-b]), b);
4017 h->base64_extra = b; 4185 h->base64_extra = b;
4018 t = base64_encode(buf2, z-b); 4186 t = base64_encode(buf2, z-b);
4019 if (t) { 4187 if (t) {
4020 DEBUG_READ(("writing %i bytes to file as base64 [%i]. Currently %i\n", z, strlen(t), size)); 4188 DEBUG_READ(("writing %i bytes to file as base64 [%i]. Currently %i\n", z, strlen(t), size));
4021 pst_fwrite(t, 1, strlen(t), h->fp); 4189 pst_fwrite(t, 1, strlen(t), h->fp);
4022 free(t); // caught by valgrind 4190 free(t); // caught by valgrind
4023 } 4191 }
4024 } 4192 }
4025 else if (h->fp) { 4193 else if (h->fp) {
4026 DEBUG_READ(("writing %i bytes to file. Currently %i\n", z, size)); 4194 DEBUG_READ(("writing %i bytes to file. Currently %i\n", z, size));
4027 pst_fwrite(buf2, 1, z, h->fp); 4195 pst_fwrite(buf2, 1, z, h->fp);
4028 } 4196 }
4029 size += z; 4197 size += z;
4030 y++; 4198 y++;
4031 } 4199 }
4032 else { 4200 else {
4033 if ((z = _pst_ff_compile_ID(pf, x, h, size)) == 0) { 4201 if ((z = _pst_ff_compile_ID(pf, x, h, size)) == 0) {
4034 DEBUG_WARN(("recursive called returned zero %i\n", z)); 4202 DEBUG_WARN(("recursive called returned zero %i\n", z));
4035 free(buf3); 4203 free(buf3);
4036 DEBUG_RET(); 4204 DEBUG_RET();
4037 return z; 4205 return z;
4038 } 4206 }
4039 size = z; 4207 size = z;
4040 y++; 4208 y++;
4041 } 4209 }
4042 } 4210 }
4043 free(buf3); 4211 free(buf3);
4044 if (buf2) free(buf2); 4212 if (buf2) free(buf2);
4045 DEBUG_RET(); 4213 DEBUG_RET();
4046 return size; 4214 return size;
4047 } 4215 }
4048 4216
4049 4217
4050 #ifdef _MSC_VER 4218 #ifdef _MSC_VER
4051 char * fileTimeToAscii(const FILETIME* filetime) { 4219 char * fileTimeToAscii(const FILETIME* filetime) {
4052 time_t t; 4220 time_t t;
4053 DEBUG_ENT("fileTimeToAscii"); 4221 DEBUG_ENT("fileTimeToAscii");
4054 t = fileTimeToUnixTime(filetime, 0); 4222 t = fileTimeToUnixTime(filetime, 0);
4055 if (t == -1) 4223 if (t == -1)
4056 DEBUG_WARN(("ERROR time_t varible that was produced, is -1\n")); 4224 DEBUG_WARN(("ERROR time_t varible that was produced, is -1\n"));
4057 DEBUG_RET(); 4225 DEBUG_RET();
4058 return ctime(&t); 4226 return ctime(&t);
4059 } 4227 }
4060 4228
4061 4229
4062 time_t fileTimeToUnixTime(const FILETIME* filetime, DWORD *x) { 4230 time_t fileTimeToUnixTime(const FILETIME* filetime, DWORD *x) {
4063 SYSTEMTIME s; 4231 SYSTEMTIME s;
4064 struct tm t; 4232 struct tm t;
4065 DEBUG_ENT("fileTimeToUnixTime"); 4233 DEBUG_ENT("fileTimeToUnixTime");
4066 memset (&t, 0, sizeof(struct tm)); 4234 memset (&t, 0, sizeof(struct tm));
4067 FileTimeToSystemTime(filetime, &s); 4235 FileTimeToSystemTime(filetime, &s);
4068 t.tm_year = s.wYear-1900; // this is what is required 4236 t.tm_year = s.wYear-1900; // this is what is required
4069 t.tm_mon = s.wMonth-1; // also required! It made me a bit confused 4237 t.tm_mon = s.wMonth-1; // also required! It made me a bit confused
4070 t.tm_mday = s.wDay; 4238 t.tm_mday = s.wDay;
4071 t.tm_hour = s.wHour; 4239 t.tm_hour = s.wHour;
4072 t.tm_min = s.wMinute; 4240 t.tm_min = s.wMinute;
4073 t.tm_sec = s.wSecond; 4241 t.tm_sec = s.wSecond;
4074 DEBUG_RET(); 4242 DEBUG_RET();
4075 return mktime(&t); 4243 return mktime(&t);
4076 } 4244 }
4077 4245
4078 4246
4079 struct tm * fileTimeToStructTM (const FILETIME *filetime) { 4247 struct tm * fileTimeToStructTM (const FILETIME *filetime) {
4080 time_t t1; 4248 time_t t1;
4081 t1 = fileTimeToUnixTime(filetime, 0); 4249 t1 = fileTimeToUnixTime(filetime, 0);
4082 return gmtime(&t1); 4250 return gmtime(&t1);
4083 } 4251 }
4084 4252
4085 4253
4086 #endif //_MSC_VER 4254 #endif //_MSC_VER
4087 4255
4088 int32_t pst_stricmp(char *a, char *b) { 4256 int32_t pst_stricmp(char *a, char *b) {
4089 // compare strings case-insensitive. 4257 // compare strings case-insensitive.
4090 // returns -1 if a < b, 0 if a==b, 1 if a > b 4258 // returns -1 if a < b, 0 if a==b, 1 if a > b
4091 while(*a != '\0' && *b != '\0' && toupper(*a)==toupper(*b)) { 4259 while(*a != '\0' && *b != '\0' && toupper(*a)==toupper(*b)) {
4092 a++; b++; 4260 a++; b++;
4093 } 4261 }
4094 if (toupper(*a) == toupper(*b)) 4262 if (toupper(*a) == toupper(*b))
4095 return 0; 4263 return 0;
4096 else if (toupper(*a) < toupper(*b)) 4264 else if (toupper(*a) < toupper(*b))
4097 return -1; 4265 return -1;
4098 else 4266 else
4099 return 1; 4267 return 1;
4100 } 4268 }
4101 4269
4102 4270
4103 int32_t pst_strincmp(char *a, char *b, int32_t x) { 4271 int32_t pst_strincmp(char *a, char *b, int32_t x) {
4104 // compare upto x chars in string a and b case-insensitively 4272 // compare upto x chars in string a and b case-insensitively
4105 // returns -1 if a < b, 0 if a==b, 1 if a > b 4273 // returns -1 if a < b, 0 if a==b, 1 if a > b
4106 int32_t y = 0; 4274 int32_t y = 0;
4107 while (*a != '\0' && *b != '\0' && y < x && toupper(*a)==toupper(*b)) { 4275 while (*a != '\0' && *b != '\0' && y < x && toupper(*a)==toupper(*b)) {
4108 a++; b++; y++; 4276 a++; b++; y++;
4109 } 4277 }
4110 // if we have reached the end of either string, or a and b still match 4278 // if we have reached the end of either string, or a and b still match
4111 if (*a == '\0' || *b == '\0' || toupper(*a)==toupper(*b)) 4279 if (*a == '\0' || *b == '\0' || toupper(*a)==toupper(*b))
4112 return 0; 4280 return 0;
4113 else if (toupper(*a) < toupper(*b)) 4281 else if (toupper(*a) < toupper(*b))
4114 return -1; 4282 return -1;
4115 else 4283 else
4116 return 1; 4284 return 1;
4117 } 4285 }
4118 4286
4119 4287
4120 size_t pst_fwrite(const void*ptr, size_t size, size_t nmemb, FILE*stream) { 4288 size_t pst_fwrite(const void*ptr, size_t size, size_t nmemb, FILE*stream) {
4121 size_t r; 4289 size_t r;
4122 DEBUG_ENT("pst_fwrite"); 4290 DEBUG_ENT("pst_fwrite");
4123 if (ptr) 4291 if (ptr)
4124 r = fwrite(ptr, size, nmemb, stream); 4292 r = fwrite(ptr, size, nmemb, stream);
4125 else { 4293 else {
4126 r = 0; 4294 r = 0;
4127 DEBUG_WARN(("An attempt to write a NULL Pointer was made\n")); 4295 DEBUG_WARN(("An attempt to write a NULL Pointer was made\n"));
4128 } 4296 }
4129 DEBUG_RET(); 4297 DEBUG_RET();
4130 return r; 4298 return r;
4131 } 4299 }
4132 4300
4133 4301
4134 char * _pst_wide_to_single(char *wt, int32_t size) { 4302 char * _pst_wide_to_single(char *wt, int32_t size) {
4135 // returns the first byte of each wide char. the size is the number of bytes in source 4303 // returns the first byte of each wide char. the size is the number of bytes in source
4136 char *x, *y; 4304 char *x, *y;
4137 DEBUG_ENT("_pst_wide_to_single"); 4305 DEBUG_ENT("_pst_wide_to_single");
4138 x = xmalloc((size/2)+1); 4306 x = xmalloc((size/2)+1);
4139 y = x; 4307 y = x;
4140 while (size != 0 && *wt != '\0') { 4308 while (size != 0 && *wt != '\0') {
4141 *y = *wt; 4309 *y = *wt;
4142 wt+=2; 4310 wt+=2;
4143 size -= 2; 4311 size -= 2;
4144 y++; 4312 y++;
4145 } 4313 }
4146 *y = '\0'; 4314 *y = '\0';
4147 DEBUG_RET(); 4315 DEBUG_RET();
4148 return x; 4316 return x;
4149 } 4317 }
4150 4318
4319
4320 char *pst_rfc2426_escape(char *str) {
4321 static char* buf = NULL;
4322 char *ret, *a, *b;
4323 int x = 0, y, z;
4324 DEBUG_ENT("rfc2426_escape");
4325 if (!str)
4326 ret = str;
4327 else {
4328
4329 // calculate space required to escape all the following characters
4330 y = pst_chr_count(str, ',')
4331 + pst_chr_count(str, '\\')
4332 + pst_chr_count(str, ';')
4333 + pst_chr_count(str, '\n');
4334 z = pst_chr_count(str, '\r');
4335 if (y == 0 && z == 0)
4336 // there isn't any extra space required
4337 ret = str;
4338 else {
4339 x = strlen(str) + y - z + 1; // don't forget room for the NUL
4340 buf = (char*) realloc(buf, x);
4341 a = str;
4342 b = buf;
4343 while (*a != '\0') {
4344 switch (*a) {
4345 case ',' :
4346 case '\\':
4347 case ';' :
4348 *(b++) = '\\';
4349 *b = *a;
4350 break;
4351 case '\n': // newlines are encoded as "\n"
4352 *(b++) = '\\';
4353 *b = 'n';
4354 break;
4355 case '\r': // skip cr
4356 b--;
4357 break;
4358 default:
4359 *b=*a;
4360 }
4361 b++;
4362 a++;
4363 }
4364 *b = '\0'; // NUL-terminate the string (buf)
4365 ret = buf;
4366 }
4367 }
4368 DEBUG_RET();
4369 return ret;
4370 }
4371
4372
4373 int pst_chr_count(char *str, char x) {
4374 int r = 0;
4375 while (*str != '\0') {
4376 if (*str == x)
4377 r++;
4378 str++;
4379 }
4380 return r;
4381 }
4382
4383
4384 char *pst_rfc2425_datetime_format(FILETIME *ft) {
4385 static char* buffer = NULL;
4386 struct tm *stm = NULL;
4387 DEBUG_ENT("rfc2425_datetime_format");
4388 if (!buffer) buffer = malloc(30); // should be enough for the date as defined below
4389 stm = fileTimeToStructTM(ft);
4390 if (strftime(buffer, 30, "%Y-%m-%dT%H:%M:%SZ", stm)==0) {
4391 DEBUG_INFO(("Problem occured formatting date\n"));
4392 }
4393 DEBUG_RET();
4394 return buffer;
4395 }
4396
4397
4398 char *pst_rfc2445_datetime_format(FILETIME *ft) {
4399 static char* buffer = NULL;
4400 struct tm *stm = NULL;
4401 DEBUG_ENT("rfc2445_datetime_format");
4402 if (!buffer) buffer = malloc(30); // should be enough for the date as defined below
4403 stm = fileTimeToStructTM(ft);
4404 if (strftime(buffer, 30, "%Y%m%dT%H%M%SZ", stm)==0) {
4405 DEBUG_INFO(("Problem occured formatting date\n"));
4406 }
4407 DEBUG_RET();
4408 return buffer;
4409 }
4410
4411