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