Mercurial > libpst

comparison libpst.c @ 10:a818f3c2e589

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