Mercurial > libpst
annotate src/libpst.c @ 59:7d5c637aaafb
General cleanup and code fixes.
Use autoscan to cleanup our autoconf system.
Use autoconf to detect when we need to use our XGetopt files and other header files.
Decode BCC field.
Fix missing LE32_CPU byte swapping for FILETIME types.
| author | Carl Byington <carl@five-ten-sg.com> |
|---|---|
| date | Thu, 14 Feb 2008 14:55:32 -0800 |
| parents | a8b772313ff4 |
| children | 97b7706bdda2 |
| 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")); |
| 46 | 1174 if (item) pst_freeItem(item); |
| 1175 if (id2_head) pst_free_id2(id2_head); | |
| 43 | 1176 DEBUG_RET(); |
| 1177 return NULL; | |
| 1178 } | |
| 1179 else { | |
| 1180 x = 0; | |
| 1181 while (x < list->count_array) { | |
| 1182 attach = (pst_item_attach*) xmalloc (sizeof(pst_item_attach)); | |
| 1183 memset (attach, 0, sizeof(pst_item_attach)); | |
| 1184 attach->next = item->attach; | |
| 1185 item->attach = attach; | |
| 1186 x++; | |
| 1187 } | |
| 1188 | |
| 46 | 1189 if (pst_process(list, item, item->attach)) { |
| 1190 DEBUG_WARN(("ERROR pst_process() failed with attachments\n")); | |
| 1191 if (item) pst_freeItem(item); | |
| 1192 if (list) pst_free_list(list); | |
| 1193 if (id2_head) pst_free_id2(id2_head); | |
| 43 | 1194 DEBUG_RET(); |
| 1195 return NULL; | |
| 1196 } | |
| 46 | 1197 if (list) pst_free_list(list); |
| 43 | 1198 list = NULL; |
| 1199 | |
| 1200 // now we will have initial information of each attachment stored in item->attach... | |
| 1201 // we must now read the secondary record for each based on the id2 val associated with | |
| 1202 // each attachment | |
| 1203 attach = item->attach; | |
| 1204 while (attach) { | |
| 46 | 1205 if ((id_ptr = pst_getID2(id2_head, attach->id2_val))) { |
| 43 | 1206 // id_ptr is a record describing the attachment |
| 1207 // we pass NULL instead of id2_head cause we don't want it to | |
| 1208 // load all the extra stuff here. | |
| 48 | 1209 if ((list = pst_parse_block(pf, id_ptr->id, NULL, NULL)) == NULL) { |
| 43 | 1210 DEBUG_WARN(("ERROR error processing an attachment record\n")); |
| 1211 attach = attach->next; | |
| 1212 continue; | |
| 1213 } | |
| 46 | 1214 if (pst_process(list, item, attach)) { |
| 1215 DEBUG_WARN(("ERROR pst_process() failed with an attachment\n")); | |
| 1216 if (list) pst_free_list(list); | |
| 43 | 1217 list = NULL; |
| 1218 attach = attach->next; | |
| 1219 continue; | |
| 1220 } | |
| 46 | 1221 if (list) pst_free_list(list); |
| 43 | 1222 list = NULL; |
| 46 | 1223 id_ptr = pst_getID2(id2_head, attach->id2_val); |
| 43 | 1224 if (id_ptr) { |
| 1225 // id2_val has been updated to the ID2 value of the datablock containing the | |
| 1226 // attachment data | |
| 1227 attach->id_val = id_ptr->id; | |
| 1228 } else { | |
| 46 | 1229 DEBUG_WARN(("have not located the correct value for the attachment [%#llx]\n", attach->id2_val)); |
| 43 | 1230 } |
| 1231 } else { | |
| 46 | 1232 DEBUG_WARN(("ERROR cannot locate id2 value %#llx\n", attach->id2_val)); |
| 43 | 1233 } |
| 1234 attach = attach->next; | |
| 1235 } | |
| 1236 } | |
| 1237 } | |
| 1238 | |
| 46 | 1239 if (id2_head) pst_free_id2(id2_head); |
| 43 | 1240 DEBUG_RET(); |
| 1241 return item; | |
| 16 | 1242 } |
| 1243 | |
| 1244 | |
| 49 | 1245 static void freeall(pst_subblocks *subs, pst_block_offset_pointer *p1, |
| 1246 pst_block_offset_pointer *p2, | |
| 1247 pst_block_offset_pointer *p3, | |
| 1248 pst_block_offset_pointer *p4, | |
| 1249 pst_block_offset_pointer *p5, | |
| 1250 pst_block_offset_pointer *p6, | |
| 1251 pst_block_offset_pointer *p7); | |
| 1252 static void freeall(pst_subblocks *subs, pst_block_offset_pointer *p1, | |
| 1253 pst_block_offset_pointer *p2, | |
| 1254 pst_block_offset_pointer *p3, | |
| 1255 pst_block_offset_pointer *p4, | |
| 1256 pst_block_offset_pointer *p5, | |
| 1257 pst_block_offset_pointer *p6, | |
| 1258 pst_block_offset_pointer *p7) { | |
| 1259 size_t i; | |
| 1260 for (i=0; i<subs->subblock_count; i++) { | |
| 1261 if (subs->subs[i].buf) free(subs->subs[i].buf); | |
| 1262 } | |
| 1263 free(subs->subs); | |
| 43 | 1264 if (p1->needfree) free(p1->from); |
| 1265 if (p2->needfree) free(p2->from); | |
| 1266 if (p3->needfree) free(p3->from); | |
| 1267 if (p4->needfree) free(p4->from); | |
| 1268 if (p5->needfree) free(p5->from); | |
| 1269 if (p6->needfree) free(p6->from); | |
| 1270 if (p7->needfree) free(p7->from); | |
| 35 | 1271 } |
| 1272 | |
| 1273 | |
| 48 | 1274 pst_num_array * pst_parse_block(pst_file *pf, uint64_t block_id, pst_index2_ll *i2_head, pst_num_array *na_head) { |
| 52 | 1275 char *buf = NULL; |
| 1276 size_t read_size = 0; | |
| 49 | 1277 pst_subblocks subblocks; |
| 48 | 1278 pst_num_array *na_ptr = NULL; |
| 43 | 1279 pst_block_offset_pointer block_offset1; |
| 1280 pst_block_offset_pointer block_offset2; | |
| 1281 pst_block_offset_pointer block_offset3; | |
| 1282 pst_block_offset_pointer block_offset4; | |
| 1283 pst_block_offset_pointer block_offset5; | |
| 1284 pst_block_offset_pointer block_offset6; | |
| 1285 pst_block_offset_pointer block_offset7; | |
| 46 | 1286 int32_t x; |
| 1287 int num_recs; | |
| 1288 int count_rec; | |
| 1289 int32_t num_list; | |
| 1290 int32_t cur_list; | |
| 47 | 1291 int block_type; |
| 43 | 1292 uint32_t rec_size = 0; |
| 1293 unsigned char* list_start; | |
| 1294 unsigned char* fr_ptr; | |
| 1295 unsigned char* to_ptr; | |
| 46 | 1296 unsigned char* ind2_end = NULL; |
| 43 | 1297 unsigned char* ind2_ptr = NULL; |
| 1298 pst_x_attrib_ll *mapptr; | |
| 50 | 1299 pst_block_hdr block_hdr; |
| 1300 pst_table3_rec table3_rec; //for type 3 (0x0101) blocks | |
| 48 | 1301 |
| 43 | 1302 struct { |
| 1303 unsigned char seven_c; | |
| 1304 unsigned char item_count; | |
| 1305 uint16_t u1; | |
| 1306 uint16_t u2; | |
| 1307 uint16_t u3; | |
| 1308 uint16_t rec_size; | |
| 1309 uint32_t b_five_offset; | |
| 1310 uint32_t ind2_offset; | |
| 1311 uint16_t u7; | |
| 1312 uint16_t u8; | |
| 1313 } seven_c_blk; | |
| 48 | 1314 |
| 43 | 1315 struct _type_d_rec { |
| 1316 uint32_t id; | |
| 1317 uint32_t u1; | |
| 1318 } * type_d_rec; | |
| 1319 | |
| 48 | 1320 struct { |
| 1321 uint16_t type; | |
| 1322 uint16_t ref_type; | |
| 1323 uint32_t value; | |
| 1324 } table_rec; //for type 1 (0xBCEC) blocks | |
| 1325 | |
| 1326 struct { | |
| 1327 uint16_t ref_type; | |
| 1328 uint16_t type; | |
| 1329 uint16_t ind2_off; | |
| 1330 uint8_t size; | |
| 1331 uint8_t slot; | |
| 1332 } table2_rec; //for type 2 (0x7CEC) blocks | |
| 1333 | |
| 46 | 1334 DEBUG_ENT("pst_parse_block"); |
| 1335 if ((read_size = pst_ff_getIDblock_dec(pf, block_id, &buf)) == 0) { | |
| 1336 WARN(("Error reading block id %#llx\n", block_id)); | |
| 43 | 1337 if (buf) free (buf); |
| 1338 DEBUG_RET(); | |
| 1339 return NULL; | |
| 1340 } | |
| 1341 | |
| 1342 block_offset1.needfree = 0; | |
| 1343 block_offset2.needfree = 0; | |
| 1344 block_offset3.needfree = 0; | |
| 1345 block_offset4.needfree = 0; | |
| 1346 block_offset5.needfree = 0; | |
| 1347 block_offset6.needfree = 0; | |
| 1348 block_offset7.needfree = 0; | |
| 1349 | |
| 1350 memcpy(&block_hdr, buf, sizeof(block_hdr)); | |
| 1351 LE16_CPU(block_hdr.index_offset); | |
| 1352 LE16_CPU(block_hdr.type); | |
| 1353 LE32_CPU(block_hdr.offset); | |
| 48 | 1354 DEBUG_EMAIL(("block header (index_offset=%#hx, type=%#hx, offset=%#hx)\n", block_hdr.index_offset, block_hdr.type, block_hdr.offset)); |
| 43 | 1355 |
| 49 | 1356 if (block_hdr.index_offset == (uint16_t)0x0101) { //type 3 |
| 50 | 1357 size_t i; |
| 1358 char *b_ptr = buf + 8; | |
| 49 | 1359 subblocks.subblock_count = block_hdr.type; |
| 1360 subblocks.subs = malloc(sizeof(pst_subblock) * subblocks.subblock_count); | |
| 1361 for (i=0; i<subblocks.subblock_count; i++) { | |
| 1362 b_ptr += pst_decode_type3(pf, &table3_rec, b_ptr); | |
| 1363 subblocks.subs[i].buf = NULL; | |
| 1364 subblocks.subs[i].read_size = pst_ff_getIDblock_dec(pf, table3_rec.id, &subblocks.subs[i].buf); | |
| 1365 if (subblocks.subs[i].buf) { | |
| 1366 memcpy(&block_hdr, subblocks.subs[i].buf, sizeof(block_hdr)); | |
| 1367 LE16_CPU(block_hdr.index_offset); | |
| 1368 subblocks.subs[i].i_offset = block_hdr.index_offset; | |
| 1369 } | |
| 1370 else { | |
| 1371 subblocks.subs[i].read_size = 0; | |
| 1372 subblocks.subs[i].i_offset = 0; | |
| 1373 } | |
| 1374 } | |
| 1375 free(buf); | |
| 1376 memcpy(&block_hdr, subblocks.subs[0].buf, sizeof(block_hdr)); | |
| 1377 LE16_CPU(block_hdr.index_offset); | |
| 1378 LE16_CPU(block_hdr.type); | |
| 1379 LE32_CPU(block_hdr.offset); | |
| 1380 DEBUG_EMAIL(("block header (index_offset=%#hx, type=%#hx, offset=%#hx)\n", block_hdr.index_offset, block_hdr.type, block_hdr.offset)); | |
| 1381 } | |
| 1382 else { | |
| 1383 // setup the subblock descriptors, but we only have one block | |
| 50 | 1384 subblocks.subblock_count = (size_t)1; |
| 49 | 1385 subblocks.subs = malloc(sizeof(pst_subblock)); |
| 1386 subblocks.subs[0].buf = buf; | |
| 1387 subblocks.subs[0].read_size = read_size; | |
| 1388 subblocks.subs[0].i_offset = block_hdr.index_offset; | |
| 1389 } | |
| 43 | 1390 |
| 46 | 1391 if (block_hdr.type == (uint16_t)0xBCEC) { //type 1 |
| 43 | 1392 block_type = 1; |
| 1393 | |
| 49 | 1394 if (pst_getBlockOffsetPointer(pf, i2_head, &subblocks, block_hdr.offset, &block_offset1)) { |
| 43 | 1395 DEBUG_WARN(("internal error (bc.b5 offset %#x) in reading block id %#x\n", block_hdr.offset, block_id)); |
| 49 | 1396 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 43 | 1397 DEBUG_RET(); |
| 1398 return NULL; | |
| 1399 } | |
| 1400 memcpy(&table_rec, block_offset1.from, sizeof(table_rec)); | |
| 1401 LE16_CPU(table_rec.type); | |
| 1402 LE16_CPU(table_rec.ref_type); | |
| 1403 LE32_CPU(table_rec.value); | |
| 1404 DEBUG_EMAIL(("table_rec (type=%#hx, ref_type=%#hx, value=%#x)\n", table_rec.type, table_rec.ref_type, table_rec.value)); | |
| 1405 | |
| 46 | 1406 if (table_rec.type != (uint16_t)0x02B5) { |
| 1407 WARN(("Unknown second block constant - %#hx for id %#llx\n", table_rec.type, block_id)); | |
| 43 | 1408 DEBUG_HEXDUMPC(buf, sizeof(table_rec), 0x10); |
| 49 | 1409 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 43 | 1410 DEBUG_RET(); |
| 1411 return NULL; | |
| 1412 } | |
| 1413 | |
| 49 | 1414 if (pst_getBlockOffsetPointer(pf, i2_head, &subblocks, table_rec.value, &block_offset2)) { |
| 43 | 1415 DEBUG_WARN(("internal error (bc.b5.desc offset) in reading block id %#x\n", table_rec.value, block_id)); |
| 49 | 1416 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 43 | 1417 DEBUG_RET(); |
| 1418 return NULL; | |
| 1419 } | |
| 1420 list_start = block_offset2.from; | |
| 1421 to_ptr = block_offset2.to; | |
| 1422 num_list = (to_ptr - list_start)/sizeof(table_rec); | |
| 1423 num_recs = 1; // only going to be one object in these blocks | |
| 1424 } | |
| 46 | 1425 else if (block_hdr.type == (uint16_t)0x7CEC) { //type 2 |
| 43 | 1426 block_type = 2; |
| 1427 | |
| 49 | 1428 if (pst_getBlockOffsetPointer(pf, i2_head, &subblocks, block_hdr.offset, &block_offset3)) { |
| 43 | 1429 DEBUG_WARN(("internal error (7c.7c offset %#x) in reading block id %#x\n", block_hdr.offset, block_id)); |
| 49 | 1430 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 43 | 1431 DEBUG_RET(); |
| 1432 return NULL; | |
| 1433 } | |
| 1434 fr_ptr = block_offset3.from; //now got pointer to "7C block" | |
| 1435 memset(&seven_c_blk, 0, sizeof(seven_c_blk)); | |
| 1436 memcpy(&seven_c_blk, fr_ptr, sizeof(seven_c_blk)); | |
| 1437 LE16_CPU(seven_c_blk.u1); | |
| 1438 LE16_CPU(seven_c_blk.u2); | |
| 1439 LE16_CPU(seven_c_blk.u3); | |
| 1440 LE16_CPU(seven_c_blk.rec_size); | |
| 1441 LE32_CPU(seven_c_blk.b_five_offset); | |
| 1442 LE32_CPU(seven_c_blk.ind2_offset); | |
| 1443 LE16_CPU(seven_c_blk.u7); | |
| 1444 LE16_CPU(seven_c_blk.u8); | |
| 1445 | |
| 1446 list_start = fr_ptr + sizeof(seven_c_blk); // the list of item numbers start after this record | |
| 1447 | |
| 1448 if (seven_c_blk.seven_c != 0x7C) { // this would mean it isn't a 7C block! | |
| 1449 WARN(("Error. There isn't a 7C where I want to see 7C!\n")); | |
| 49 | 1450 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 43 | 1451 DEBUG_RET(); |
| 1452 return NULL; | |
| 1453 } | |
| 1454 | |
| 1455 rec_size = seven_c_blk.rec_size; | |
| 47 | 1456 num_list = (int32_t)(unsigned)seven_c_blk.item_count; |
| 43 | 1457 |
| 49 | 1458 if (pst_getBlockOffsetPointer(pf, i2_head, &subblocks, seven_c_blk.b_five_offset, &block_offset4)) { |
| 43 | 1459 DEBUG_WARN(("internal error (7c.b5 offset %#x) in reading block id %#x\n", seven_c_blk.b_five_offset, block_id)); |
| 49 | 1460 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 43 | 1461 DEBUG_RET(); |
| 1462 return NULL; | |
| 1463 } | |
| 1464 memcpy(&table_rec, block_offset4.from, sizeof(table_rec)); | |
| 1465 LE16_CPU(table_rec.type); | |
| 1466 LE16_CPU(table_rec.ref_type); | |
| 1467 LE32_CPU(table_rec.value); | |
| 1468 | |
| 46 | 1469 if (table_rec.type != (uint16_t)0x04B5) { // different constant than a type 1 record |
| 1470 WARN(("Unknown second block constant - %#hx for id %#llx\n", table_rec.type, block_id)); | |
| 49 | 1471 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 43 | 1472 DEBUG_RET(); |
| 1473 return NULL; | |
| 1474 } | |
| 1475 | |
| 49 | 1476 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
|
1477 DEBUG_WARN(("internal error (7c.b5.desc offset %#x) in reading block id %#llx\n", table_rec.value, block_id)); |
| 49 | 1478 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 43 | 1479 DEBUG_RET(); |
| 1480 return NULL; | |
| 1481 } | |
| 1482 num_recs = (block_offset5.to - block_offset5.from) / 6; // this will give the number of records in this block | |
| 1483 | |
| 49 | 1484 if (pst_getBlockOffsetPointer(pf, i2_head, &subblocks, seven_c_blk.ind2_offset, &block_offset6)) { |
| 43 | 1485 DEBUG_WARN(("internal error (7c.ind2 offset %#x) in reading block id %#x\n", seven_c_blk.ind2_offset, block_id)); |
| 49 | 1486 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 43 | 1487 DEBUG_RET(); |
| 1488 return NULL; | |
| 1489 } | |
| 1490 ind2_ptr = block_offset6.from; | |
| 1491 ind2_end = block_offset6.to; | |
| 1492 } | |
| 49 | 1493 else { |
| 46 | 1494 WARN(("ERROR: Unknown block constant - %#hx for id %#llx\n", block_hdr.type, block_id)); |
| 43 | 1495 DEBUG_HEXDUMPC(buf, read_size,0x10); |
| 49 | 1496 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 43 | 1497 DEBUG_RET(); |
| 1498 return NULL; | |
| 1499 } | |
| 1500 | |
| 1501 DEBUG_EMAIL(("Mallocing number of records %i\n", num_recs)); | |
| 1502 for (count_rec=0; count_rec<num_recs; count_rec++) { | |
| 1503 na_ptr = (pst_num_array*) xmalloc(sizeof(pst_num_array)); | |
| 1504 memset(na_ptr, 0, sizeof(pst_num_array)); | |
| 1505 na_ptr->next = na_head; | |
| 1506 na_head = na_ptr; | |
| 49 | 1507 // allocate an array of count num_recs to contain sizeof(pst_num_item) |
| 1508 na_ptr->items = (pst_num_item**) xmalloc(sizeof(pst_num_item)*num_list); | |
| 43 | 1509 na_ptr->count_item = num_list; |
| 1510 na_ptr->orig_count = num_list; | |
| 47 | 1511 na_ptr->count_array = (int32_t)num_recs; // each record will have a record of the total number of records |
| 43 | 1512 for (x=0; x<num_list; x++) na_ptr->items[x] = NULL; |
| 1513 x = 0; | |
| 1514 | |
| 1515 DEBUG_EMAIL(("going to read %i (%#x) items\n", na_ptr->count_item, na_ptr->count_item)); | |
| 1516 | |
| 1517 fr_ptr = list_start; // initialize fr_ptr to the start of the list. | |
| 1518 for (cur_list=0; cur_list<num_list; cur_list++) { //we will increase fr_ptr as we progress through index | |
| 1519 unsigned char* value_pointer = NULL; // needed for block type 2 with values larger than 4 bytes | |
| 46 | 1520 size_t value_size = 0; |
| 47 | 1521 if (block_type == 1) { |
| 43 | 1522 memcpy(&table_rec, fr_ptr, sizeof(table_rec)); |
| 1523 LE16_CPU(table_rec.type); | |
| 1524 LE16_CPU(table_rec.ref_type); | |
| 1525 //LE32_CPU(table_rec.value); // done later, some may be order invariant | |
| 1526 fr_ptr += sizeof(table_rec); | |
| 47 | 1527 } else if (block_type == 2) { |
| 43 | 1528 // we will copy the table2_rec values into a table_rec record so that we can keep the rest of the code |
| 1529 memcpy(&table2_rec, fr_ptr, sizeof(table2_rec)); | |
| 1530 LE16_CPU(table2_rec.ref_type); | |
| 1531 LE16_CPU(table2_rec.type); | |
| 1532 LE16_CPU(table2_rec.ind2_off); | |
| 1533 | |
| 1534 // table_rec and table2_rec are arranged differently, so assign the values across | |
| 1535 table_rec.type = table2_rec.type; | |
| 1536 table_rec.ref_type = table2_rec.ref_type; | |
| 1537 table_rec.value = 0; | |
| 50 | 1538 if ((ind2_end - ind2_ptr) >= (int)(table2_rec.ind2_off + table2_rec.size)) { |
| 46 | 1539 size_t n = table2_rec.size; |
| 1540 size_t m = sizeof(table_rec.value); | |
| 43 | 1541 if (n <= m) { |
| 1542 memcpy(&table_rec.value, ind2_ptr + table2_rec.ind2_off, n); | |
| 1543 } | |
| 1544 else { | |
| 1545 value_pointer = ind2_ptr + table2_rec.ind2_off; | |
| 1546 value_size = n; | |
| 1547 } | |
| 1548 //LE32_CPU(table_rec.value); // done later, some may be order invariant | |
| 1549 } | |
| 1550 else { | |
| 1551 DEBUG_WARN (("Trying to read outside buffer, buffer size %#x, offset %#x, data size %#x\n", | |
| 1552 read_size, ind2_end-ind2_ptr+table2_rec.ind2_off, table2_rec.size)); | |
| 1553 } | |
| 1554 fr_ptr += sizeof(table2_rec); | |
| 1555 } else { | |
| 1556 WARN(("Missing code for block_type %i\n", block_type)); | |
| 49 | 1557 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 46 | 1558 if (na_head) pst_free_list(na_head); |
| 43 | 1559 DEBUG_RET(); |
| 1560 return NULL; | |
| 1561 } | |
| 1562 DEBUG_EMAIL(("reading block %i (type=%#x, ref_type=%#x, value=%#x)\n", | |
| 1563 x, table_rec.type, table_rec.ref_type, table_rec.value)); | |
| 1564 | |
| 1565 if (!na_ptr->items[x]) { | |
| 49 | 1566 na_ptr->items[x] = (pst_num_item*) xmalloc(sizeof(pst_num_item)); |
| 43 | 1567 } |
| 49 | 1568 memset(na_ptr->items[x], 0, sizeof(pst_num_item)); //init it |
| 43 | 1569 |
| 1570 // check here to see if the id of the attribute is a mapped one | |
| 1571 mapptr = pf->x_head; | |
| 1572 while (mapptr && (mapptr->map < table_rec.type)) mapptr = mapptr->next; | |
| 1573 if (mapptr && (mapptr->map == table_rec.type)) { | |
| 1574 if (mapptr->mytype == PST_MAP_ATTRIB) { | |
| 46 | 1575 na_ptr->items[x]->id = *((uint32_t*)mapptr->data); |
| 43 | 1576 DEBUG_EMAIL(("Mapped attrib %#x to %#x\n", table_rec.type, na_ptr->items[x]->id)); |
| 1577 } else if (mapptr->mytype == PST_MAP_HEADER) { | |
| 1578 DEBUG_EMAIL(("Internet Header mapping found %#x\n", table_rec.type)); | |
| 46 | 1579 na_ptr->items[x]->id = (uint32_t)PST_ATTRIB_HEADER; |
| 43 | 1580 na_ptr->items[x]->extra = mapptr->data; |
| 1581 } | |
| 46 | 1582 else { |
| 1583 // nothing, should be assertion failure here | |
| 1584 } | |
| 43 | 1585 } else { |
| 1586 na_ptr->items[x]->id = table_rec.type; | |
| 1587 } | |
| 1588 na_ptr->items[x]->type = 0; // checked later before it is set | |
| 1589 /* Reference Types | |
| 1590 0x0002 - Signed 16bit value | |
| 1591 0x0003 - Signed 32bit value | |
| 1592 0x0004 - 4-byte floating point | |
| 1593 0x0005 - Floating point double | |
| 1594 0x0006 - Signed 64-bit int | |
| 1595 0x0007 - Application Time | |
| 1596 0x000A - 32-bit error value | |
| 1597 0x000B - Boolean (non-zero = true) | |
| 1598 0x000D - Embedded Object | |
| 1599 0x0014 - 8-byte signed integer (64-bit) | |
| 1600 0x001E - Null terminated String | |
| 1601 0x001F - Unicode string | |
| 1602 0x0040 - Systime - Filetime structure | |
| 1603 0x0048 - OLE Guid | |
| 1604 0x0102 - Binary data | |
| 1605 0x1003 - Array of 32bit values | |
| 1606 0x1014 - Array of 64bit values | |
| 1607 0x101E - Array of Strings | |
| 1608 0x1102 - Array of Binary data | |
| 1609 */ | |
| 1610 | |
| 46 | 1611 if (table_rec.ref_type == (uint16_t)0x0002 || |
| 1612 table_rec.ref_type == (uint16_t)0x0003 || | |
| 1613 table_rec.ref_type == (uint16_t)0x000b) { | |
| 43 | 1614 //contains 32 bits of data |
| 1615 na_ptr->items[x]->size = sizeof(int32_t); | |
| 1616 na_ptr->items[x]->type = table_rec.ref_type; | |
| 1617 na_ptr->items[x]->data = xmalloc(sizeof(int32_t)); | |
| 1618 memcpy(na_ptr->items[x]->data, &(table_rec.value), sizeof(int32_t)); | |
| 51 | 1619 // are we missing an LE32_CPU() call here? table_rec.value is still |
| 1620 // in the original order. | |
| 43 | 1621 |
| 46 | 1622 } else if (table_rec.ref_type == (uint16_t)0x0005 || |
| 1623 table_rec.ref_type == (uint16_t)0x000d || | |
| 1624 table_rec.ref_type == (uint16_t)0x0014 || | |
| 1625 table_rec.ref_type == (uint16_t)0x001e || | |
| 1626 table_rec.ref_type == (uint16_t)0x001f || | |
| 1627 table_rec.ref_type == (uint16_t)0x0040 || | |
| 1628 table_rec.ref_type == (uint16_t)0x0048 || | |
| 1629 table_rec.ref_type == (uint16_t)0x0102 || | |
| 1630 table_rec.ref_type == (uint16_t)0x1003 || | |
| 1631 table_rec.ref_type == (uint16_t)0x1014 || | |
| 1632 table_rec.ref_type == (uint16_t)0x101e || | |
| 1633 table_rec.ref_type == (uint16_t)0x1102) { | |
| 43 | 1634 //contains index reference to data |
| 1635 LE32_CPU(table_rec.value); | |
| 1636 if (value_pointer) { | |
| 1637 // in a type 2 block, with a value that is more than 4 bytes | |
| 1638 // directly stored in this block. | |
| 1639 na_ptr->items[x]->size = value_size; | |
| 1640 na_ptr->items[x]->type = table_rec.ref_type; | |
| 1641 na_ptr->items[x]->data = xmalloc(value_size); | |
| 1642 memcpy(na_ptr->items[x]->data, value_pointer, value_size); | |
| 1643 } | |
| 49 | 1644 else if (pst_getBlockOffsetPointer(pf, i2_head, &subblocks, table_rec.value, &block_offset7)) { |
| 46 | 1645 if ((table_rec.value & 0xf) == (uint32_t)0xf) { |
| 43 | 1646 DEBUG_WARN(("failed to get block offset for table_rec.value of %#x to be read later.\n", table_rec.value)); |
| 1647 na_ptr->items[x]->size = 0; | |
| 1648 na_ptr->items[x]->data = NULL; | |
| 1649 na_ptr->items[x]->type = table_rec.value; | |
| 1650 } | |
| 1651 else { | |
| 1652 if (table_rec.value) { | |
| 1653 DEBUG_WARN(("failed to get block offset for table_rec.value of %#x\n", table_rec.value)); | |
| 1654 } | |
| 1655 na_ptr->count_item --; //we will be skipping a row | |
| 1656 continue; | |
| 1657 } | |
| 1658 } | |
| 1659 else { | |
| 50 | 1660 value_size = (size_t)(block_offset7.to - block_offset7.from); |
| 43 | 1661 na_ptr->items[x]->size = value_size; |
| 1662 na_ptr->items[x]->type = table_rec.ref_type; | |
| 1663 na_ptr->items[x]->data = xmalloc(value_size+1); | |
| 1664 memcpy(na_ptr->items[x]->data, block_offset7.from, value_size); | |
| 1665 na_ptr->items[x]->data[value_size] = '\0'; // it might be a string, null terminate it. | |
| 1666 } | |
| 46 | 1667 if (table_rec.ref_type == (uint16_t)0xd) { |
| 43 | 1668 // there is still more to do for the type of 0xD embedded objects |
| 1669 type_d_rec = (struct _type_d_rec*) na_ptr->items[x]->data; | |
| 1670 LE32_CPU(type_d_rec->id); | |
| 46 | 1671 na_ptr->items[x]->size = pst_ff_getID2block(pf, type_d_rec->id, i2_head, &(na_ptr->items[x]->data)); |
| 43 | 1672 if (!na_ptr->items[x]->size){ |
| 1673 DEBUG_WARN(("not able to read the ID2 data. Setting to be read later. %#x\n", type_d_rec->id)); | |
| 1674 na_ptr->items[x]->type = type_d_rec->id; // fetch before freeing data, alias pointer | |
| 1675 free(na_ptr->items[x]->data); | |
| 1676 na_ptr->items[x]->data = NULL; | |
| 1677 } | |
| 1678 } | |
| 46 | 1679 if (table_rec.ref_type == (uint16_t)0x1f) { |
| 43 | 1680 // there is more to do for the type 0x1f unicode strings |
| 46 | 1681 static vbuf *strbuf = NULL; |
| 1682 static vbuf *unibuf = NULL; | |
| 1683 if (!strbuf) strbuf=vballoc((size_t)1024); | |
| 1684 if (!unibuf) unibuf=vballoc((size_t)1024); | |
| 1685 | |
| 1686 // splint barfed on the following lines | |
| 1687 //VBUF_STATIC(strbuf, 1024); | |
| 1688 //VBUF_STATIC(unibuf, 1024); | |
| 1689 | |
| 43 | 1690 //need UTF-16 zero-termination |
| 1691 vbset(strbuf, na_ptr->items[x]->data, na_ptr->items[x]->size); | |
| 46 | 1692 vbappend(strbuf, "\0\0", (size_t)2); |
| 44 | 1693 DEBUG_INDEX(("Iconv in:\n")); |
| 43 | 1694 DEBUG_HEXDUMPC(strbuf->b, strbuf->dlen, 0x10); |
| 46 | 1695 (void)vb_utf16to8(unibuf, strbuf->b, strbuf->dlen); |
| 43 | 1696 free(na_ptr->items[x]->data); |
| 1697 na_ptr->items[x]->size = unibuf->dlen; | |
| 1698 na_ptr->items[x]->data = xmalloc(unibuf->dlen); | |
| 1699 memcpy(na_ptr->items[x]->data, unibuf->b, unibuf->dlen); | |
| 44 | 1700 DEBUG_INDEX(("Iconv out:\n")); |
| 43 | 1701 DEBUG_HEXDUMPC(na_ptr->items[x]->data, na_ptr->items[x]->size, 0x10); |
| 1702 } | |
| 1703 if (na_ptr->items[x]->type == 0) na_ptr->items[x]->type = table_rec.ref_type; | |
| 1704 } else { | |
| 46 | 1705 WARN(("ERROR Unknown ref_type %#hx\n", table_rec.ref_type)); |
| 49 | 1706 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 46 | 1707 if (na_head) pst_free_list(na_head); |
| 43 | 1708 DEBUG_RET(); |
| 1709 return NULL; | |
| 1710 } | |
| 1711 x++; | |
| 1712 } | |
| 1713 DEBUG_EMAIL(("increasing ind2_ptr by %i [%#x] bytes. Was %#x, Now %#x\n", rec_size, rec_size, ind2_ptr, ind2_ptr+rec_size)); | |
| 1714 ind2_ptr += rec_size; | |
| 1715 } | |
| 49 | 1716 freeall(&subblocks, &block_offset1, &block_offset2, &block_offset3, &block_offset4, &block_offset5, &block_offset6, &block_offset7); |
| 43 | 1717 DEBUG_RET(); |
| 1718 return na_head; | |
| 16 | 1719 } |
| 1720 | |
| 51 | 1721 |
| 48 | 1722 // This version of free does NULL check first |
| 1723 #define SAFE_FREE(x) {if (x) free(x);} | |
| 1724 | |
| 16 | 1725 |
| 1726 // check if item->email is NULL, and init if so | |
| 43 | 1727 #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) );} } |
| 1728 #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) );} } | |
| 1729 #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 | 1730 #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 | 1731 #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) );} } |
| 1732 #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
|
1733 // malloc space and copy the current item's data null terminated |
| 43 | 1734 #define LIST_COPY(targ, type) { \ |
| 1735 targ = type realloc(targ, list->items[x]->size+1); \ | |
| 1736 memcpy(targ, list->items[x]->data, list->items[x]->size); \ | |
| 46 | 1737 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
|
1738 } |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
1739 // malloc space and copy the item filetime |
|
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
1740 #define LIST_COPY_TIME(targ) { \ |
|
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
1741 targ = (FILETIME*) realloc(targ, sizeof(FILETIME)); \ |
|
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
1742 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
|
1743 LE32_CPU(targ->dwLowDateTime); \ |
|
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
1744 LE32_CPU(targ->dwHighDateTime); \ |
|
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
1745 } |
|
41
183ae993b9ad
security fix for potential buffer overrun in lz decompress
carl
parents:
40
diff
changeset
|
1746 // malloc space and copy the current item's data and size |
| 48 | 1747 #define LIST_COPY_SIZE(targ, type, mysize) { \ |
| 1748 mysize = list->items[x]->size; \ | |
| 1749 if (mysize) { \ | |
| 1750 targ = type realloc(targ, mysize); \ | |
| 1751 memcpy(targ, list->items[x]->data, mysize); \ | |
| 1752 } \ | |
| 1753 else { \ | |
| 1754 SAFE_FREE(targ); \ | |
| 1755 targ = NULL; \ | |
| 1756 } \ | |
| 16 | 1757 } |
| 1758 | |
| 1759 #define NULL_CHECK(x) { if (!x) { DEBUG_EMAIL(("NULL_CHECK: Null Found\n")); break;} } | |
| 1760 | |
| 1761 #define MOVE_NEXT(targ) { \ | |
| 43 | 1762 if (next){\ |
| 1763 if (!targ) {\ | |
| 1764 DEBUG_EMAIL(("MOVE_NEXT: Target is NULL. Will stop processing this option\n"));\ | |
| 1765 break;\ | |
| 1766 }\ | |
| 1767 targ = targ->next;\ | |
| 1768 if (!targ) {\ | |
| 1769 DEBUG_EMAIL(("MOVE_NEXT: Target is NULL after next. Will stop processing this option\n"));\ | |
| 1770 break;\ | |
| 1771 }\ | |
| 1772 next=0;\ | |
| 1773 }\ | |
| 16 | 1774 } |
| 1775 | |
| 1776 | |
| 46 | 1777 int pst_process(pst_num_array *list , pst_item *item, pst_item_attach *attach) { |
| 43 | 1778 int32_t x, t; |
| 47 | 1779 int next = 0; |
| 43 | 1780 pst_item_extra_field *ef; |
| 1781 | |
| 46 | 1782 DEBUG_ENT("pst_process"); |
| 43 | 1783 if (!item) { |
| 1784 DEBUG_EMAIL(("item cannot be NULL.\n")); | |
| 1785 DEBUG_RET(); | |
| 1786 return -1; | |
| 1787 } | |
| 1788 | |
| 1789 while (list) { | |
| 1790 x = 0; | |
| 1791 while (x < list->count_item) { | |
| 1792 // check here to see if the id is one that is mapped. | |
| 1793 DEBUG_EMAIL(("#%d - id: %#x type: %#x length: %#x\n", x, list->items[x]->id, list->items[x]->type, list->items[x]->size)); | |
| 1794 | |
| 1795 switch (list->items[x]->id) { | |
| 1796 case PST_ATTRIB_HEADER: // CUSTOM attribute for saying the Extra Headers | |
| 1797 DEBUG_EMAIL(("Extra Field - ")); | |
| 49 | 1798 if (list->items[x]->extra) { |
| 1799 ef = (pst_item_extra_field*) xmalloc(sizeof(pst_item_extra_field)); | |
| 1800 memset(ef, 0, sizeof(pst_item_extra_field)); | |
| 1801 ef->field_name = (char*) xmalloc(strlen(list->items[x]->extra)+1); | |
| 1802 strcpy(ef->field_name, list->items[x]->extra); | |
| 1803 LIST_COPY(ef->value, (char*)); | |
| 1804 ef->next = item->extra_fields; | |
| 1805 item->extra_fields = ef; | |
| 1806 DEBUG_EMAIL(("\"%s\" = \"%s\"\n", ef->field_name, ef->value)); | |
| 1807 } | |
| 1808 else { | |
| 1809 DEBUG_EMAIL(("NULL extra field\n")); | |
| 1810 } | |
| 43 | 1811 break; |
| 1812 case 0x0002: // PR_ALTERNATE_RECIPIENT_ALLOWED | |
| 1813 // If set to true, the sender allows this email to be autoforwarded | |
| 1814 DEBUG_EMAIL(("AutoForward allowed - ")); | |
| 1815 MALLOC_EMAIL(item); | |
| 51 | 1816 if (*(int16_t*)list->items[x]->data) { |
| 43 | 1817 DEBUG_EMAIL(("True\n")); |
| 1818 item->email->autoforward = 1; | |
| 1819 } else { | |
| 1820 DEBUG_EMAIL(("False\n")); | |
| 1821 item->email->autoforward = -1; | |
| 1822 } | |
| 1823 break; | |
| 1824 case 0x0003: // Extended Attributes table | |
| 1825 DEBUG_EMAIL(("Extended Attributes Table - NOT PROCESSED\n")); | |
| 1826 break; | |
| 1827 case 0x0017: // PR_IMPORTANCE | |
| 1828 // How important the sender deems it to be | |
| 1829 // 0 - Low | |
| 1830 // 1 - Normal | |
| 1831 // 2 - High | |
| 1832 | |
| 1833 DEBUG_EMAIL(("Importance Level - ")); | |
| 1834 MALLOC_EMAIL(item); | |
| 1835 memcpy(&(item->email->importance), list->items[x]->data, sizeof(item->email->importance)); | |
| 1836 LE32_CPU(item->email->importance); | |
| 1837 t = item->email->importance; | |
| 47 | 1838 DEBUG_EMAIL(("%s [%i]\n", ((int)t==0?"Low":((int)t==1?"Normal":"High")), t)); |
| 43 | 1839 break; |
| 1840 case 0x001A: // PR_MESSAGE_CLASS Ascii type of messages - NOT FOLDERS | |
| 1841 // must be case insensitive | |
| 1842 DEBUG_EMAIL(("IPM.x - ")); | |
| 1843 LIST_COPY(item->ascii_type, (char*)); | |
| 1844 if (pst_strincmp("IPM.Note", item->ascii_type, 8) == 0) | |
| 1845 // the string begins with IPM.Note... | |
| 1846 item->type = PST_TYPE_NOTE; | |
| 1847 else if (pst_stricmp("IPM", item->ascii_type) == 0) | |
| 1848 // the whole string is just IPM | |
| 1849 item->type = PST_TYPE_NOTE; | |
| 1850 else if (pst_strincmp("IPM.Contact", item->ascii_type, 11) == 0) | |
| 1851 // the string begins with IPM.Contact... | |
| 1852 item->type = PST_TYPE_CONTACT; | |
| 1853 else if (pst_strincmp("REPORT.IPM.Note", item->ascii_type, 15) == 0) | |
| 1854 // the string begins with the above | |
| 1855 item->type = PST_TYPE_REPORT; | |
| 1856 else if (pst_strincmp("IPM.Activity", item->ascii_type, 12) == 0) | |
| 1857 item->type = PST_TYPE_JOURNAL; | |
| 1858 else if (pst_strincmp("IPM.Appointment", item->ascii_type, 15) == 0) | |
| 1859 item->type = PST_TYPE_APPOINTMENT; | |
| 50 | 1860 else if (pst_strincmp("IPM.Task", item->ascii_type, 8) == 0) |
| 1861 item->type = PST_TYPE_TASK; | |
| 43 | 1862 else |
| 1863 item->type = PST_TYPE_OTHER; | |
| 1864 | |
| 1865 DEBUG_EMAIL(("%s\n", item->ascii_type)); | |
| 1866 break; | |
| 1867 case 0x0023: // PR_ORIGINATOR_DELIVERY_REPORT_REQUESTED | |
| 1868 // set if the sender wants a delivery report from all recipients | |
| 1869 DEBUG_EMAIL(("Global Delivery Report - ")); | |
| 1870 MALLOC_EMAIL(item); | |
| 51 | 1871 if (*(int16_t*)list->items[x]->data) { |
| 43 | 1872 DEBUG_EMAIL(("True\n")); |
| 1873 item->email->delivery_report = 1; | |
| 1874 } else { | |
| 1875 DEBUG_EMAIL(("False\n")); | |
| 1876 item->email->delivery_report = 0; | |
| 1877 } | |
| 1878 break; | |
| 1879 case 0x0026: // PR_PRIORITY | |
| 1880 // Priority of a message | |
| 1881 // -1 NonUrgent | |
| 1882 // 0 Normal | |
| 1883 // 1 Urgent | |
| 1884 DEBUG_EMAIL(("Priority - ")); | |
| 1885 MALLOC_EMAIL(item); | |
| 1886 memcpy(&(item->email->priority), list->items[x]->data, sizeof(item->email->priority)); | |
| 1887 LE32_CPU(item->email->priority); | |
| 1888 t = item->email->priority; | |
| 1889 DEBUG_EMAIL(("%s [%i]\n", (t<0?"NonUrgent":(t==0?"Normal":"Urgent")), t)); | |
| 1890 break; | |
| 51 | 1891 case 0x0029: // PR_READ_RECEIPT_REQUESTED |
| 43 | 1892 DEBUG_EMAIL(("Read Receipt - ")); |
| 1893 MALLOC_EMAIL(item); | |
| 51 | 1894 if (*(int16_t*)list->items[x]->data) { |
| 43 | 1895 DEBUG_EMAIL(("True\n")); |
| 1896 item->email->read_receipt = 1; | |
| 1897 } else { | |
| 1898 DEBUG_EMAIL(("False\n")); | |
| 1899 item->email->read_receipt = 0; | |
| 1900 } | |
| 1901 break; | |
| 1902 case 0x002B: // PR_RECIPIENT_REASSIGNMENT_PROHIBITED | |
| 1903 DEBUG_EMAIL(("Reassignment Prohibited (Private) - ")); | |
| 51 | 1904 if (*(int16_t*)list->items[x]->data) { |
| 43 | 1905 DEBUG_EMAIL(("True\n")); |
| 1906 item->private_member = 1; | |
| 1907 } else { | |
| 1908 DEBUG_EMAIL(("False\n")); | |
| 1909 item->private_member = 0; | |
| 1910 } | |
| 1911 break; | |
| 1912 case 0x002E: // PR_ORIGINAL_SENSITIVITY | |
| 1913 // the sensitivity of the message before being replied to or forwarded | |
| 1914 // 0 - None | |
| 1915 // 1 - Personal | |
| 1916 // 2 - Private | |
| 1917 // 3 - Company Confidential | |
| 1918 DEBUG_EMAIL(("Original Sensitivity - ")); | |
| 1919 MALLOC_EMAIL(item); | |
| 1920 memcpy(&(item->email->orig_sensitivity), list->items[x]->data, sizeof(item->email->orig_sensitivity)); | |
| 1921 LE32_CPU(item->email->orig_sensitivity); | |
| 1922 t = item->email->orig_sensitivity; | |
| 47 | 1923 DEBUG_EMAIL(("%s [%i]\n", ((int)t==0?"None":((int)t==1?"Personal": |
| 1924 ((int)t==2?"Private":"Company Confidential"))), t)); | |
| 43 | 1925 break; |
| 1926 case 0x0036: // PR_SENSITIVITY | |
| 1927 // sender's opinion of the sensitivity of an email | |
| 1928 // 0 - None | |
| 1929 // 1 - Personal | |
| 1930 // 2 - Private | |
| 1931 // 3 - Company Confidiential | |
| 1932 DEBUG_EMAIL(("Sensitivity - ")); | |
| 1933 MALLOC_EMAIL(item); | |
| 1934 memcpy(&(item->email->sensitivity), list->items[x]->data, sizeof(item->email->sensitivity)); | |
| 1935 LE32_CPU(item->email->sensitivity); | |
| 1936 t = item->email->sensitivity; | |
| 47 | 1937 DEBUG_EMAIL(("%s [%i]\n", ((int)t==0?"None":((int)t==1?"Personal": |
| 1938 ((int)t==2?"Private":"Company Confidential"))), t)); | |
| 43 | 1939 break; |
| 1940 case 0x0037: // PR_SUBJECT raw subject | |
| 1941 DEBUG_EMAIL(("Raw Subject - ")); | |
| 1942 MALLOC_EMAIL(item); | |
| 1943 item->email->subject = (pst_item_email_subject*) realloc(item->email->subject, sizeof(pst_item_email_subject)); | |
| 1944 memset(item->email->subject, 0, sizeof(pst_item_email_subject)); | |
| 1945 DEBUG_EMAIL((" [size = %i] ", list->items[x]->size)); | |
| 1946 if (list->items[x]->size > 0) { | |
| 1947 if (isprint(list->items[x]->data[0])) { | |
| 1948 // then there are no control bytes at the front | |
| 1949 item->email->subject->off1 = 0; | |
| 1950 item->email->subject->off2 = 0; | |
| 1951 item->email->subject->subj = realloc(item->email->subject->subj, list->items[x]->size+1); | |
| 1952 memset(item->email->subject->subj, 0, list->items[x]->size+1); | |
| 1953 memcpy(item->email->subject->subj, list->items[x]->data, list->items[x]->size); | |
| 1954 } else { | |
| 1955 DEBUG_EMAIL(("Raw Subject has control codes\n")); | |
| 1956 // there might be some control bytes in the first and second bytes | |
| 47 | 1957 item->email->subject->off1 = (int)(unsigned)list->items[x]->data[0]; |
| 1958 item->email->subject->off2 = (int)(unsigned)list->items[x]->data[1]; | |
| 1959 item->email->subject->subj = realloc(item->email->subject->subj, list->items[x]->size-1); | |
| 43 | 1960 memset(item->email->subject->subj, 0, list->items[x]->size-1); |
| 1961 memcpy(item->email->subject->subj, &(list->items[x]->data[2]), list->items[x]->size-2); | |
| 1962 } | |
| 1963 DEBUG_EMAIL(("%s\n", item->email->subject->subj)); | |
| 1964 } else { | |
| 1965 // obviously outlook has decided not to be straight with this one. | |
| 1966 item->email->subject->off1 = 0; | |
| 1967 item->email->subject->off2 = 0; | |
| 1968 item->email->subject = NULL; | |
| 1969 DEBUG_EMAIL(("NULL subject detected\n")); | |
| 1970 } | |
| 1971 break; | |
| 1972 case 0x0039: // PR_CLIENT_SUBMIT_TIME Date Email Sent/Created | |
| 1973 DEBUG_EMAIL(("Date sent - ")); | |
| 1974 MALLOC_EMAIL(item); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
1975 LIST_COPY_TIME(item->email->sent_date); |
| 43 | 1976 DEBUG_EMAIL(("%s", fileTimeToAscii(item->email->sent_date))); |
| 1977 break; | |
| 1978 case 0x003B: // PR_SENT_REPRESENTING_SEARCH_KEY Sender address 1 | |
| 1979 DEBUG_EMAIL(("Sent on behalf of address 1 - ")); | |
| 1980 MALLOC_EMAIL(item); | |
| 1981 LIST_COPY(item->email->outlook_sender, (char*)); | |
| 1982 DEBUG_EMAIL(("%s\n", item->email->outlook_sender)); | |
| 1983 break; | |
| 1984 case 0x003F: // PR_RECEIVED_BY_ENTRYID Structure containing Recipient | |
| 1985 DEBUG_EMAIL(("Recipient Structure 1 -- NOT HANDLED\n")); | |
| 1986 break; | |
| 1987 case 0x0040: // PR_RECEIVED_BY_NAME Name of Recipient Structure | |
| 1988 DEBUG_EMAIL(("Received By Name 1 -- NOT HANDLED\n")); | |
| 1989 break; | |
| 1990 case 0x0041: // PR_SENT_REPRESENTING_ENTRYID Structure containing Sender | |
| 1991 DEBUG_EMAIL(("Sent on behalf of Structure 1 -- NOT HANDLED\n")); | |
| 1992 break; | |
| 1993 case 0x0042: // PR_SENT_REPRESENTING_NAME Name of Sender Structure | |
| 1994 DEBUG_EMAIL(("Sent on behalf of Structure Name - ")); | |
| 1995 MALLOC_EMAIL(item); | |
| 1996 LIST_COPY(item->email->outlook_sender_name, (char*)); | |
| 1997 DEBUG_EMAIL(("%s\n", item->email->outlook_sender_name)); | |
| 1998 break; | |
| 1999 case 0x0043: // PR_RCVD_REPRESENTING_ENTRYID Recipient Structure 2 | |
| 2000 DEBUG_EMAIL(("Received on behalf of Structure -- NOT HANDLED\n")); | |
| 2001 break; | |
| 2002 case 0x0044: // PR_RCVD_REPRESENTING_NAME Name of Recipient Structure 2 | |
| 2003 DEBUG_EMAIL(("Received on behalf of Structure Name -- NOT HANDLED\n")); | |
| 2004 break; | |
| 2005 case 0x004F: // PR_REPLY_RECIPIENT_ENTRIES Reply-To Structure | |
| 2006 DEBUG_EMAIL(("Reply-To Structure -- NOT HANDLED\n")); | |
| 2007 break; | |
| 2008 case 0x0050: // PR_REPLY_RECIPIENT_NAMES Name of Reply-To Structure | |
| 2009 DEBUG_EMAIL(("Name of Reply-To Structure -")); | |
| 2010 MALLOC_EMAIL(item); | |
| 2011 LIST_COPY(item->email->reply_to, (char*)); | |
| 2012 DEBUG_EMAIL(("%s\n", item->email->reply_to)); | |
| 2013 break; | |
| 2014 case 0x0051: // PR_RECEIVED_BY_SEARCH_KEY Recipient Address 1 | |
| 2015 DEBUG_EMAIL(("Recipient's Address 1 (Search Key) - ")); | |
| 2016 MALLOC_EMAIL(item); | |
| 2017 LIST_COPY (item->email->outlook_recipient, (char*)); | |
| 2018 DEBUG_EMAIL(("%s\n", item->email->outlook_recipient)); | |
| 2019 break; | |
| 2020 case 0x0052: // PR_RCVD_REPRESENTING_SEARCH_KEY Recipient Address 2 | |
| 2021 DEBUG_EMAIL(("Received on behalf of Address (Search Key) - ")); | |
| 2022 MALLOC_EMAIL(item); | |
| 2023 LIST_COPY(item->email->outlook_recipient2, (char*)); | |
| 2024 DEBUG_EMAIL(("%s\n", item->email->outlook_recipient2)); | |
| 2025 break; | |
| 2026 case 0x0057: // PR_MESSAGE_TO_ME | |
| 2027 // this user is listed explicitly in the TO address | |
| 2028 DEBUG_EMAIL(("My address in TO field - ")); | |
| 2029 MALLOC_EMAIL(item); | |
| 51 | 2030 if (*(int16_t*)list->items[x]->data) { |
| 43 | 2031 DEBUG_EMAIL(("True\n")); |
| 2032 item->email->message_to_me = 1; | |
| 2033 } else { | |
| 2034 DEBUG_EMAIL(("False\n")); | |
| 2035 item->email->message_to_me = 0; | |
| 2036 } | |
| 2037 break; | |
| 2038 case 0x0058: // PR_MESSAGE_CC_ME | |
| 2039 // this user is listed explicitly in the CC address | |
| 2040 DEBUG_EMAIL(("My address in CC field - ")); | |
| 2041 MALLOC_EMAIL(item); | |
| 51 | 2042 if (*(int16_t*)list->items[x]->data) { |
| 43 | 2043 DEBUG_EMAIL(("True\n")); |
| 2044 item->email->message_cc_me = 1; | |
| 2045 } else { | |
| 2046 DEBUG_EMAIL(("False\n")); | |
| 2047 item->email->message_cc_me = 0; | |
| 2048 } | |
| 2049 break; | |
| 51 | 2050 case 0x0059: // PR_MESSAGE_RECIP_ME |
| 43 | 2051 // this user appears in TO, CC or BCC address list |
| 2052 DEBUG_EMAIL(("Message addressed to me - ")); | |
| 2053 MALLOC_EMAIL(item); | |
| 51 | 2054 if (*(int16_t*)list->items[x]->data) { |
| 43 | 2055 DEBUG_EMAIL(("True\n")); |
| 2056 item->email->message_recip_me = 1; | |
| 2057 } else { | |
| 2058 DEBUG_EMAIL(("False\n")); | |
| 2059 item->email->message_recip_me = 0; | |
| 2060 } | |
| 2061 break; | |
| 2062 case 0x0063: // PR_RESPONSE_REQUESTED | |
| 2063 DEBUG_EMAIL(("Response requested - ")); | |
| 51 | 2064 if (*(int16_t*)list->items[x]->data) { |
| 43 | 2065 DEBUG_EMAIL(("True\n")); |
| 2066 item->response_requested = 1; | |
| 2067 } else { | |
| 2068 DEBUG_EMAIL(("False\n")); | |
| 2069 item->response_requested = 0; | |
| 2070 } | |
| 2071 break; | |
| 2072 case 0x0064: // PR_SENT_REPRESENTING_ADDRTYPE Access method for Sender Address | |
| 2073 DEBUG_EMAIL(("Sent on behalf of address type - ")); | |
| 2074 MALLOC_EMAIL(item); | |
| 2075 LIST_COPY(item->email->sender_access, (char*)); | |
| 2076 DEBUG_EMAIL(("%s\n", item->email->sender_access)); | |
| 2077 break; | |
| 2078 case 0x0065: // PR_SENT_REPRESENTING_EMAIL_ADDRESS Sender Address | |
| 2079 DEBUG_EMAIL(("Sent on behalf of Address - ")); | |
| 2080 MALLOC_EMAIL(item); | |
| 2081 LIST_COPY(item->email->sender_address, (char*)); | |
| 2082 DEBUG_EMAIL(("%s\n", item->email->sender_address)); | |
| 2083 break; | |
| 2084 case 0x0070: // PR_CONVERSATION_TOPIC Processed Subject | |
| 2085 DEBUG_EMAIL(("Processed Subject (Conversation Topic) - ")); | |
| 2086 MALLOC_EMAIL(item); | |
| 2087 LIST_COPY(item->email->proc_subject, (char*)); | |
| 2088 DEBUG_EMAIL(("%s\n", item->email->proc_subject)); | |
| 2089 break; | |
| 2090 case 0x0071: // PR_CONVERSATION_INDEX Date 2 | |
| 2091 DEBUG_EMAIL(("Conversation Index - ")); | |
| 2092 MALLOC_EMAIL(item); | |
| 2093 memcpy(&(item->email->conv_index), list->items[x]->data, sizeof(item->email->conv_index)); | |
| 2094 DEBUG_EMAIL(("%i\n", item->email->conv_index)); | |
| 2095 break; | |
| 2096 case 0x0075: // PR_RECEIVED_BY_ADDRTYPE Recipient Access Method | |
| 2097 DEBUG_EMAIL(("Received by Address type - ")); | |
| 2098 MALLOC_EMAIL(item); | |
| 2099 LIST_COPY(item->email->recip_access, (char*)); | |
| 2100 DEBUG_EMAIL(("%s\n", item->email->recip_access)); | |
| 2101 break; | |
| 2102 case 0x0076: // PR_RECEIVED_BY_EMAIL_ADDRESS Recipient Address | |
| 2103 DEBUG_EMAIL(("Received by Address - ")); | |
| 2104 MALLOC_EMAIL(item); | |
| 2105 LIST_COPY(item->email->recip_address, (char*)); | |
| 2106 DEBUG_EMAIL(("%s\n", item->email->recip_address)); | |
| 2107 break; | |
| 2108 case 0x0077: // PR_RCVD_REPRESENTING_ADDRTYPE Recipient Access Method 2 | |
| 2109 DEBUG_EMAIL(("Received on behalf of Address type - ")); | |
| 2110 MALLOC_EMAIL(item); | |
| 2111 LIST_COPY(item->email->recip2_access, (char*)); | |
| 2112 DEBUG_EMAIL(("%s\n", item->email->recip2_access)); | |
| 2113 break; | |
| 2114 case 0x0078: // PR_RCVD_REPRESENTING_EMAIL_ADDRESS Recipient Address 2 | |
| 2115 DEBUG_EMAIL(("Received on behalf of Address -")); | |
| 2116 MALLOC_EMAIL(item); | |
| 2117 LIST_COPY(item->email->recip2_address, (char*)); | |
| 2118 DEBUG_EMAIL(("%s\n", item->email->recip2_address)); | |
| 2119 break; | |
| 2120 case 0x007D: // PR_TRANSPORT_MESSAGE_HEADERS Internet Header | |
| 2121 DEBUG_EMAIL(("Internet Header - ")); | |
| 2122 MALLOC_EMAIL(item); | |
| 2123 LIST_COPY(item->email->header, (char*)); | |
| 46 | 2124 DEBUG_EMAIL(("%s\n", item->email->header)); |
| 43 | 2125 DEBUG_EMAIL(("NOT PRINTED\n")); |
| 2126 break; | |
| 2127 case 0x0C17: // PR_REPLY_REQUESTED | |
| 2128 DEBUG_EMAIL(("Reply Requested - ")); | |
| 2129 MALLOC_EMAIL(item); | |
| 51 | 2130 if (*(int16_t*)list->items[x]->data) { |
| 43 | 2131 DEBUG_EMAIL(("True\n")); |
| 2132 item->email->reply_requested = 1; | |
| 2133 } else { | |
| 2134 DEBUG_EMAIL(("False\n")); | |
| 2135 item->email->reply_requested = 0; | |
| 2136 } | |
| 2137 break; | |
| 2138 case 0x0C19: // PR_SENDER_ENTRYID Sender Structure 2 | |
| 2139 DEBUG_EMAIL(("Sender Structure 2 -- NOT HANDLED\n")); | |
| 2140 break; | |
| 2141 case 0x0C1A: // PR_SENDER_NAME Name of Sender Structure 2 | |
| 2142 DEBUG_EMAIL(("Name of Sender Structure 2 -- NOT HANDLED\n")); | |
| 2143 break; | |
| 2144 case 0x0C1D: // PR_SENDER_SEARCH_KEY Name of Sender Address 2 | |
| 2145 DEBUG_EMAIL(("Name of Sender Address 2 (Sender search key) - ")); | |
| 2146 MALLOC_EMAIL(item); | |
| 2147 LIST_COPY(item->email->outlook_sender2, (char*)); | |
| 2148 DEBUG_EMAIL(("%s\n", item->email->outlook_sender2)); | |
| 2149 break; | |
| 2150 case 0x0C1E: // PR_SENDER_ADDRTYPE Sender Address 2 access method | |
| 2151 DEBUG_EMAIL(("Sender Address type - ")); | |
| 2152 MALLOC_EMAIL(item); | |
| 2153 LIST_COPY(item->email->sender2_access, (char*)); | |
| 2154 DEBUG_EMAIL(("%s\n", item->email->sender2_access)); | |
| 2155 break; | |
| 2156 case 0x0C1F: // PR_SENDER_EMAIL_ADDRESS Sender Address 2 | |
| 2157 DEBUG_EMAIL(("Sender Address - ")); | |
| 2158 MALLOC_EMAIL(item); | |
| 2159 LIST_COPY(item->email->sender2_address, (char*)); | |
| 2160 DEBUG_EMAIL(("%s\n", item->email->sender2_address)); | |
| 2161 break; | |
| 2162 case 0x0E01: // PR_DELETE_AFTER_SUBMIT | |
| 2163 // I am not too sure how this works | |
| 2164 DEBUG_EMAIL(("Delete after submit - ")); | |
| 2165 MALLOC_EMAIL(item); | |
| 51 | 2166 if (*(int16_t*)list->items[x]->data) { |
| 43 | 2167 DEBUG_EMAIL(("True\n")); |
| 2168 item->email->delete_after_submit = 1; | |
| 2169 } else { | |
| 2170 DEBUG_EMAIL(("False\n")); | |
| 2171 item->email->delete_after_submit = 0; | |
| 2172 } | |
| 2173 break; | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
2174 case 0x0E02: // PR_DISPLAY_BCC BCC Addresses |
|
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
2175 DEBUG_EMAIL(("Display BCC Addresses - ")); |
|
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
2176 MALLOC_EMAIL(item); |
|
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
2177 LIST_COPY(item->email->bcc_address, (char*)); |
|
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
2178 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
|
2179 break; |
| 43 | 2180 case 0x0E03: // PR_DISPLAY_CC CC Addresses |
| 2181 DEBUG_EMAIL(("Display CC Addresses - ")); | |
| 2182 MALLOC_EMAIL(item); | |
| 2183 LIST_COPY(item->email->cc_address, (char*)); | |
| 2184 DEBUG_EMAIL(("%s\n", item->email->cc_address)); | |
| 2185 break; | |
| 2186 case 0x0E04: // PR_DISPLAY_TO Address Sent-To | |
| 2187 DEBUG_EMAIL(("Display Sent-To Address - ")); | |
| 2188 MALLOC_EMAIL(item); | |
| 2189 LIST_COPY(item->email->sentto_address, (char*)); | |
| 2190 DEBUG_EMAIL(("%s\n", item->email->sentto_address)); | |
| 2191 break; | |
| 2192 case 0x0E06: // PR_MESSAGE_DELIVERY_TIME Date 3 - Email Arrival Date | |
| 2193 DEBUG_EMAIL(("Date 3 (Delivery Time) - ")); | |
| 2194 MALLOC_EMAIL(item); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
2195 LIST_COPY_TIME(item->email->arrival_date); |
| 43 | 2196 DEBUG_EMAIL(("%s", fileTimeToAscii(item->email->arrival_date))); |
| 2197 break; | |
| 2198 case 0x0E07: // PR_MESSAGE_FLAGS Email Flag | |
| 2199 // 0x01 - Read | |
| 2200 // 0x02 - Unmodified | |
| 2201 // 0x04 - Submit | |
| 2202 // 0x08 - Unsent | |
| 2203 // 0x10 - Has Attachments | |
| 2204 // 0x20 - From Me | |
| 2205 // 0x40 - Associated | |
| 2206 // 0x80 - Resend | |
| 2207 // 0x100 - RN Pending | |
| 2208 // 0x200 - NRN Pending | |
| 2209 DEBUG_EMAIL(("Message Flags - ")); | |
| 2210 MALLOC_EMAIL(item); | |
| 2211 memcpy(&(item->email->flag), list->items[x]->data, sizeof(item->email->flag)); | |
| 2212 LE32_CPU(item->email->flag); | |
| 2213 DEBUG_EMAIL(("%i\n", item->email->flag)); | |
| 2214 break; | |
| 2215 case 0x0E08: // PR_MESSAGE_SIZE Total size of a message object | |
| 2216 DEBUG_EMAIL(("Message Size - ")); | |
| 2217 memcpy(&(item->message_size), list->items[x]->data, sizeof(item->message_size)); | |
| 2218 LE32_CPU(item->message_size); | |
| 2219 DEBUG_EMAIL(("%i [%#x]\n", item->message_size, item->message_size)); | |
| 2220 break; | |
| 2221 case 0x0E0A: // PR_SENTMAIL_ENTRYID | |
| 2222 // folder that this message is sent to after submission | |
| 2223 DEBUG_EMAIL(("Sentmail EntryID - ")); | |
| 2224 MALLOC_EMAIL(item); | |
| 2225 LIST_COPY(item->email->sentmail_folder, (pst_entryid*)); | |
| 2226 LE32_CPU(item->email->sentmail_folder->id); | |
| 2227 DEBUG_EMAIL(("[id = %#x]\n", item->email->sentmail_folder->id)); | |
| 2228 break; | |
| 2229 case 0x0E1F: // PR_RTF_IN_SYNC | |
| 2230 // True means that the rtf version is same as text body | |
| 2231 // False means rtf version is more up-to-date than text body | |
| 2232 // if this value doesn't exist, text body is more up-to-date than rtf and | |
| 2233 // cannot update to the rtf | |
| 2234 DEBUG_EMAIL(("Compressed RTF in Sync - ")); | |
| 2235 MALLOC_EMAIL(item); | |
| 51 | 2236 if (*(int16_t*)list->items[x]->data) { |
| 43 | 2237 DEBUG_EMAIL(("True\n")); |
| 2238 item->email->rtf_in_sync = 1; | |
| 2239 } else { | |
| 2240 DEBUG_EMAIL(("False\n")); | |
| 2241 item->email->rtf_in_sync = 0; | |
| 2242 } | |
| 2243 break; | |
| 2244 case 0x0E20: // PR_ATTACH_SIZE binary Attachment data in record | |
| 2245 DEBUG_EMAIL(("Attachment Size - ")); | |
| 2246 NULL_CHECK(attach); | |
| 2247 MOVE_NEXT(attach); | |
| 50 | 2248 t = (*(int32_t*)list->items[x]->data); |
| 2249 LE32_CPU(t); | |
| 2250 attach->size = (size_t)t; | |
| 43 | 2251 DEBUG_EMAIL(("%i\n", attach->size)); |
| 2252 break; | |
| 2253 case 0x0FF9: // PR_RECORD_KEY Record Header 1 | |
| 2254 DEBUG_EMAIL(("Record Key 1 - ")); | |
| 2255 LIST_COPY(item->record_key, (char*)); | |
| 2256 item->record_key_size = list->items[x]->size; | |
| 2257 DEBUG_EMAIL_HEXPRINT(item->record_key, item->record_key_size); | |
| 2258 DEBUG_EMAIL(("\n")); | |
| 2259 break; | |
| 2260 case 0x1000: // PR_BODY Plain Text body | |
| 2261 DEBUG_EMAIL(("Plain Text body - ")); | |
| 2262 MALLOC_EMAIL(item); | |
| 2263 LIST_COPY(item->email->body, (char*)); | |
| 2264 //DEBUG_EMAIL("%s\n", item->email->body); | |
| 2265 DEBUG_EMAIL(("NOT PRINTED\n")); | |
| 2266 break; | |
| 2267 case 0x1006: // PR_RTF_SYNC_BODY_CRC | |
| 2268 DEBUG_EMAIL(("RTF Sync Body CRC - ")); | |
| 2269 MALLOC_EMAIL(item); | |
| 2270 memcpy(&(item->email->rtf_body_crc), list->items[x]->data, sizeof(item->email->rtf_body_crc)); | |
| 2271 LE32_CPU(item->email->rtf_body_crc); | |
| 2272 DEBUG_EMAIL(("%#x\n", item->email->rtf_body_crc)); | |
| 2273 break; | |
| 2274 case 0x1007: // PR_RTF_SYNC_BODY_COUNT | |
| 2275 // a count of the *significant* charcters in the rtf body. Doesn't count | |
| 2276 // whitespace and other ignorable characters | |
| 2277 DEBUG_EMAIL(("RTF Sync Body character count - ")); | |
| 2278 MALLOC_EMAIL(item); | |
| 2279 memcpy(&(item->email->rtf_body_char_count), list->items[x]->data, sizeof(item->email->rtf_body_char_count)); | |
| 2280 LE32_CPU(item->email->rtf_body_char_count); | |
| 2281 DEBUG_EMAIL(("%i [%#x]\n", item->email->rtf_body_char_count, item->email->rtf_body_char_count)); | |
| 2282 break; | |
| 2283 case 0x1008: // PR_RTF_SYNC_BODY_TAG | |
| 2284 // the first couple of lines of RTF body so that after modification, then beginning can | |
| 2285 // once again be found | |
| 2286 DEBUG_EMAIL(("RTF Sync body tag - ")); | |
| 2287 MALLOC_EMAIL(item); | |
| 2288 LIST_COPY(item->email->rtf_body_tag, (char*)); | |
| 2289 DEBUG_EMAIL(("%s\n", item->email->rtf_body_tag)); | |
| 2290 break; | |
| 2291 case 0x1009: // PR_RTF_COMPRESSED | |
| 2292 // some compression algorithm has been applied to this. At present | |
| 2293 // it is unknown | |
| 2294 DEBUG_EMAIL(("RTF Compressed body - ")); | |
| 2295 MALLOC_EMAIL(item); | |
| 2296 LIST_COPY_SIZE(item->email->rtf_compressed, (char*), item->email->rtf_compressed_size); | |
| 2297 DEBUG_EMAIL(("NOT PRINTED\n")); | |
| 2298 break; | |
| 2299 case 0x1010: // PR_RTF_SYNC_PREFIX_COUNT | |
| 2300 // a count of the ignored characters before the first significant character | |
| 2301 DEBUG_EMAIL(("RTF whitespace prefix count - ")); | |
| 2302 MALLOC_EMAIL(item); | |
| 2303 memcpy(&(item->email->rtf_ws_prefix_count), list->items[x]->data, sizeof(item->email->rtf_ws_prefix_count)); | |
| 2304 DEBUG_EMAIL(("%i\n", item->email->rtf_ws_prefix_count)); | |
| 2305 break; | |
| 2306 case 0x1011: // PR_RTF_SYNC_TRAILING_COUNT | |
| 2307 // a count of the ignored characters after the last significant character | |
| 2308 DEBUG_EMAIL(("RTF whitespace tailing count - ")); | |
| 2309 MALLOC_EMAIL(item); | |
| 2310 memcpy(&(item->email->rtf_ws_trailing_count), list->items[x]->data, sizeof(item->email->rtf_ws_trailing_count)); | |
| 2311 DEBUG_EMAIL(("%i\n", item->email->rtf_ws_trailing_count)); | |
| 2312 break; | |
| 2313 case 0x1013: // HTML body | |
| 2314 DEBUG_EMAIL(("HTML body - ")); | |
| 2315 MALLOC_EMAIL(item); | |
| 2316 LIST_COPY(item->email->htmlbody, (char*)); | |
| 2317 // DEBUG_EMAIL(("%s\n", item->email->htmlbody)); | |
| 2318 DEBUG_EMAIL(("NOT PRINTED\n")); | |
| 2319 break; | |
| 2320 case 0x1035: // Message ID | |
| 2321 DEBUG_EMAIL(("Message ID - ")); | |
| 2322 MALLOC_EMAIL(item); | |
| 2323 LIST_COPY(item->email->messageid, (char*)); | |
| 2324 DEBUG_EMAIL(("%s\n", item->email->messageid)); | |
| 2325 break; | |
| 2326 case 0x1042: // in-reply-to | |
| 2327 DEBUG_EMAIL(("In-Reply-To - ")); | |
| 2328 MALLOC_EMAIL(item); | |
| 2329 LIST_COPY(item->email->in_reply_to, (char*)); | |
| 2330 DEBUG_EMAIL(("%s\n", item->email->in_reply_to)); | |
| 2331 break; | |
| 2332 case 0x1046: // Return Path | |
| 2333 DEBUG_EMAIL(("Return Path - ")); | |
| 2334 MALLOC_EMAIL(item); | |
| 2335 LIST_COPY(item->email->return_path_address, (char*)); | |
| 2336 DEBUG_EMAIL(("%s\n", item->email->return_path_address)); | |
| 2337 break; | |
| 2338 case 0x3001: // PR_DISPLAY_NAME File As | |
| 2339 DEBUG_EMAIL(("Display Name - ")); | |
| 2340 LIST_COPY(item->file_as, (char*)); | |
| 2341 DEBUG_EMAIL(("%s\n", item->file_as)); | |
| 2342 break; | |
| 2343 case 0x3002: // PR_ADDRTYPE | |
| 2344 DEBUG_EMAIL(("Address Type - ")); | |
| 2345 MALLOC_CONTACT(item); | |
| 2346 LIST_COPY(item->contact->address1_transport, (char*)); | |
| 2347 DEBUG_EMAIL(("|%s|\n", item->contact->address1_transport)); | |
| 2348 break; | |
| 2349 case 0x3003: // PR_EMAIL_ADDRESS | |
| 2350 // Contact's email address | |
| 2351 DEBUG_EMAIL(("Contact Address - ")); | |
| 2352 MALLOC_CONTACT(item); | |
| 2353 LIST_COPY(item->contact->address1, (char*)); | |
| 2354 DEBUG_EMAIL(("|%s|\n", item->contact->address1)); | |
| 2355 break; | |
| 2356 case 0x3004: // PR_COMMENT Comment for item - usually folders | |
| 2357 DEBUG_EMAIL(("Comment - ")); | |
| 2358 LIST_COPY(item->comment, (char*)); | |
| 2359 DEBUG_EMAIL(("%s\n", item->comment)); | |
| 2360 break; | |
| 2361 case 0x3007: // PR_CREATION_TIME Date 4 - Creation Date? | |
| 2362 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
|
2363 LIST_COPY_TIME(item->create_date); |
| 43 | 2364 DEBUG_EMAIL(("%s", fileTimeToAscii(item->create_date))); |
| 2365 break; | |
| 2366 case 0x3008: // PR_LAST_MODIFICATION_TIME Date 5 - Modify Date | |
| 2367 DEBUG_EMAIL(("Date 5 (Modify Date) - ")); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
2368 LIST_COPY_TIME(item->modify_date); |
| 43 | 2369 DEBUG_EMAIL(("%s", fileTimeToAscii(item->modify_date))); |
| 2370 break; | |
| 2371 case 0x300B: // PR_SEARCH_KEY Record Header 2 | |
| 2372 DEBUG_EMAIL(("Record Search 2 -- NOT HANDLED\n")); | |
| 2373 break; | |
| 2374 case 0x35DF: // PR_VALID_FOLDER_MASK | |
| 2375 // States which folders are valid for this message store | |
| 2376 // FOLDER_IPM_SUBTREE_VALID 0x1 | |
| 2377 // FOLDER_IPM_INBOX_VALID 0x2 | |
| 2378 // FOLDER_IPM_OUTBOX_VALID 0x4 | |
| 2379 // FOLDER_IPM_WASTEBOX_VALID 0x8 | |
| 2380 // FOLDER_IPM_SENTMAIL_VALID 0x10 | |
| 2381 // FOLDER_VIEWS_VALID 0x20 | |
| 2382 // FOLDER_COMMON_VIEWS_VALID 0x40 | |
| 2383 // FOLDER_FINDER_VALID 0x80 | |
| 2384 DEBUG_EMAIL(("Valid Folder Mask - ")); | |
| 2385 MALLOC_MESSAGESTORE(item); | |
| 51 | 2386 memcpy(&(item->message_store->valid_mask), list->items[x]->data, sizeof(item->message_store->valid_mask)); |
| 43 | 2387 LE32_CPU(item->message_store->valid_mask); |
| 2388 DEBUG_EMAIL(("%i\n", item->message_store->valid_mask)); | |
| 2389 break; | |
| 2390 case 0x35E0: // PR_IPM_SUBTREE_ENTRYID Top of Personal Folder Record | |
| 2391 DEBUG_EMAIL(("Top of Personal Folder Record - ")); | |
| 2392 MALLOC_MESSAGESTORE(item); | |
| 2393 LIST_COPY(item->message_store->top_of_personal_folder, (pst_entryid*)); | |
| 2394 LE32_CPU(item->message_store->top_of_personal_folder->id); | |
| 2395 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->top_of_personal_folder->id)); | |
| 2396 break; | |
| 51 | 2397 case 0x35E2: // PR_IPM_OUTBOX_ENTRYID |
| 2398 DEBUG_EMAIL(("Default Outbox Folder record - ")); | |
| 2399 MALLOC_MESSAGESTORE(item); | |
| 2400 LIST_COPY(item->message_store->default_outbox_folder, (pst_entryid*)); | |
| 2401 LE32_CPU(item->message_store->default_outbox_folder->id); | |
| 2402 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->default_outbox_folder->id)); | |
| 2403 break; | |
| 2404 case 0x35E3: // PR_IPM_WASTEBASKET_ENTRYID | |
| 43 | 2405 DEBUG_EMAIL(("Deleted Items Folder record - ")); |
| 2406 MALLOC_MESSAGESTORE(item); | |
| 2407 LIST_COPY(item->message_store->deleted_items_folder, (pst_entryid*)); | |
| 2408 LE32_CPU(item->message_store->deleted_items_folder->id); | |
| 2409 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->deleted_items_folder->id)); | |
| 2410 break; | |
| 51 | 2411 case 0x35E4: // PR_IPM_SENTMAIL_ENTRYID |
| 2412 DEBUG_EMAIL(("Sent Items Folder record - ")); | |
| 2413 MALLOC_MESSAGESTORE(item); | |
| 2414 LIST_COPY(item->message_store->sent_items_folder, (pst_entryid*)); | |
| 2415 LE32_CPU(item->message_store->sent_items_folder->id); | |
| 2416 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->sent_items_folder->id)); | |
| 2417 break; | |
| 2418 case 0x35E5: // PR_VIEWS_ENTRYID | |
| 2419 DEBUG_EMAIL(("User Views Folder record - ")); | |
| 2420 MALLOC_MESSAGESTORE(item); | |
| 2421 LIST_COPY(item->message_store->user_views_folder, (pst_entryid*)); | |
| 2422 LE32_CPU(item->message_store->user_views_folder->id); | |
| 2423 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->user_views_folder->id)); | |
| 2424 break; | |
| 2425 case 0x35E6: // PR_COMMON_VIEWS_ENTRYID | |
| 2426 DEBUG_EMAIL(("Common View Folder record - ")); | |
| 2427 MALLOC_MESSAGESTORE(item); | |
| 2428 LIST_COPY(item->message_store->common_view_folder, (pst_entryid*)); | |
| 2429 LE32_CPU(item->message_store->common_view_folder->id); | |
| 2430 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->common_view_folder->id)); | |
| 2431 break; | |
| 2432 case 0x35E7: // PR_FINDER_ENTRYID | |
| 2433 DEBUG_EMAIL(("Search Root Folder record - ")); | |
| 43 | 2434 MALLOC_MESSAGESTORE(item); |
| 2435 LIST_COPY(item->message_store->search_root_folder, (pst_entryid*)); | |
| 2436 LE32_CPU(item->message_store->search_root_folder->id); | |
| 2437 DEBUG_EMAIL(("[id = %#x]\n", item->message_store->search_root_folder->id)); | |
| 2438 break; | |
| 2439 case 0x3602: // PR_CONTENT_COUNT Number of emails stored in a folder | |
| 2440 DEBUG_EMAIL(("Folder Email Count - ")); | |
| 2441 MALLOC_FOLDER(item); | |
| 2442 memcpy(&(item->folder->email_count), list->items[x]->data, sizeof(item->folder->email_count)); | |
| 2443 LE32_CPU(item->folder->email_count); | |
| 2444 DEBUG_EMAIL(("%i\n", item->folder->email_count)); | |
| 2445 break; | |
| 2446 case 0x3603: // PR_CONTENT_UNREAD Number of unread emails | |
| 2447 DEBUG_EMAIL(("Unread Email Count - ")); | |
| 2448 MALLOC_FOLDER(item); | |
| 2449 memcpy(&(item->folder->unseen_email_count), list->items[x]->data, sizeof(item->folder->unseen_email_count)); | |
| 2450 LE32_CPU(item->folder->unseen_email_count); | |
| 2451 DEBUG_EMAIL(("%i\n", item->folder->unseen_email_count)); | |
| 2452 break; | |
| 2453 case 0x360A: // PR_SUBFOLDERS Has children | |
| 2454 DEBUG_EMAIL(("Has Subfolders - ")); | |
| 2455 MALLOC_FOLDER(item); | |
| 51 | 2456 if (*(int16_t*)list->items[x]->data) { |
| 43 | 2457 DEBUG_EMAIL(("True\n")); |
| 2458 item->folder->subfolder = 1; | |
| 2459 } else { | |
| 2460 DEBUG_EMAIL(("False\n")); | |
| 2461 item->folder->subfolder = 0; | |
| 2462 } | |
| 2463 break; | |
| 2464 case 0x3613: // PR_CONTAINER_CLASS IPF.x | |
| 2465 DEBUG_EMAIL(("IPF.x - ")); | |
| 2466 LIST_COPY(item->ascii_type, (char*)); | |
| 2467 if (strncmp("IPF.Note", item->ascii_type, 8) == 0) | |
| 2468 item->type = PST_TYPE_NOTE; | |
| 2469 else if (strncmp("IPF.Contact", item->ascii_type, 11) == 0) | |
| 2470 item->type = PST_TYPE_CONTACT; | |
| 2471 else if (strncmp("IPF.Journal", item->ascii_type, 11) == 0) | |
| 2472 item->type = PST_TYPE_JOURNAL; | |
| 2473 else if (strncmp("IPF.Appointment", item->ascii_type, 15) == 0) | |
| 2474 item->type = PST_TYPE_APPOINTMENT; | |
| 2475 else if (strncmp("IPF.StickyNote", item->ascii_type, 14) == 0) | |
| 2476 item->type = PST_TYPE_STICKYNOTE; | |
| 2477 else if (strncmp("IPF.Task", item->ascii_type, 8) == 0) | |
| 2478 item->type = PST_TYPE_TASK; | |
| 2479 else | |
| 2480 item->type = PST_TYPE_OTHER; | |
| 2481 | |
| 2482 DEBUG_EMAIL(("%s [%i]\n", item->ascii_type, item->type)); | |
| 2483 break; | |
| 2484 case 0x3617: // PR_ASSOC_CONTENT_COUNT | |
| 2485 // associated content are items that are attached to this folder | |
| 2486 // but are hidden from users | |
| 2487 DEBUG_EMAIL(("Associate Content count - ")); | |
| 2488 MALLOC_FOLDER(item); | |
| 2489 memcpy(&(item->folder->assoc_count), list->items[x]->data, sizeof(item->folder->assoc_count)); | |
| 2490 LE32_CPU(item->folder->assoc_count); | |
| 2491 DEBUG_EMAIL(("%i [%#x]\n", item->folder->assoc_count, item->folder->assoc_count)); | |
| 2492 break; | |
| 2493 case 0x3701: // PR_ATTACH_DATA_OBJ binary data of attachment | |
| 2494 DEBUG_EMAIL(("Binary Data [Size %i] - ", list->items[x]->size)); | |
| 2495 NULL_CHECK(attach); | |
| 2496 MOVE_NEXT(attach); | |
| 2497 if (!list->items[x]->data) { //special case | |
| 2498 attach->id2_val = list->items[x]->type; | |
| 46 | 2499 DEBUG_EMAIL(("Seen a Reference. The data hasn't been loaded yet. [%#llx][%#x]\n", |
| 43 | 2500 attach->id2_val, list->items[x]->type)); |
| 2501 } else { | |
| 2502 LIST_COPY(attach->data, (char*)); | |
| 2503 attach->size = list->items[x]->size; | |
| 2504 DEBUG_EMAIL(("NOT PRINTED\n")); | |
| 2505 } | |
| 2506 break; | |
| 2507 case 0x3704: // PR_ATTACH_FILENAME Attachment filename (8.3) | |
| 2508 DEBUG_EMAIL(("Attachment Filename - ")); | |
| 2509 NULL_CHECK(attach); | |
| 2510 MOVE_NEXT(attach); | |
| 2511 LIST_COPY(attach->filename1, (char*)); | |
| 2512 DEBUG_EMAIL(("%s\n", attach->filename1)); | |
| 2513 break; | |
| 2514 case 0x3705: // PR_ATTACH_METHOD | |
| 2515 // 0 - No Attachment | |
| 2516 // 1 - Attach by Value | |
| 2517 // 2 - Attach by reference | |
| 2518 // 3 - Attach by ref resolve | |
| 2519 // 4 - Attach by ref only | |
| 2520 // 5 - Embedded Message | |
| 2521 // 6 - OLE | |
| 2522 DEBUG_EMAIL(("Attachment method - ")); | |
| 2523 NULL_CHECK(attach); | |
| 2524 MOVE_NEXT(attach); | |
| 2525 memcpy(&(attach->method), list->items[x]->data, sizeof(attach->method)); | |
| 2526 LE32_CPU(attach->method); | |
| 2527 t = attach->method; | |
| 2528 DEBUG_EMAIL(("%s [%i]\n", (t==0?"No Attachment": | |
| 2529 (t==1?"Attach By Value": | |
| 2530 (t==2?"Attach By Reference": | |
| 2531 (t==3?"Attach by Ref. Resolve": | |
| 2532 (t==4?"Attach by Ref. Only": | |
| 2533 (t==5?"Embedded Message":"OLE")))))),t)); | |
| 2534 break; | |
| 2535 case 0x3707: // PR_ATTACH_LONG_FILENAME Attachment filename (long?) | |
| 2536 DEBUG_EMAIL(("Attachment Filename long - ")); | |
| 2537 NULL_CHECK(attach); | |
| 2538 MOVE_NEXT(attach); | |
| 2539 LIST_COPY(attach->filename2, (char*)); | |
| 2540 DEBUG_EMAIL(("%s\n", attach->filename2)); | |
| 2541 break; | |
| 2542 case 0x370B: // PR_RENDERING_POSITION | |
| 2543 // position in characters that the attachment appears in the plain text body | |
| 2544 DEBUG_EMAIL(("Attachment Position - ")); | |
| 2545 NULL_CHECK(attach); | |
| 2546 MOVE_NEXT(attach); | |
| 2547 memcpy(&(attach->position), list->items[x]->data, sizeof(attach->position)); | |
| 2548 LE32_CPU(attach->position); | |
| 2549 DEBUG_EMAIL(("%i [%#x]\n", attach->position)); | |
| 2550 break; | |
| 2551 case 0x370E: // PR_ATTACH_MIME_TAG Mime type of encoding | |
| 2552 DEBUG_EMAIL(("Attachment mime encoding - ")); | |
| 2553 NULL_CHECK(attach); | |
| 2554 MOVE_NEXT(attach); | |
| 2555 LIST_COPY(attach->mimetype, (char*)); | |
| 2556 DEBUG_EMAIL(("%s\n", attach->mimetype)); | |
| 2557 break; | |
| 2558 case 0x3710: // PR_ATTACH_MIME_SEQUENCE | |
| 2559 // sequence number for mime parts. Includes body | |
| 2560 DEBUG_EMAIL(("Attachment Mime Sequence - ")); | |
| 2561 NULL_CHECK(attach); | |
| 2562 MOVE_NEXT(attach); | |
| 2563 memcpy(&(attach->sequence), list->items[x]->data, sizeof(attach->sequence)); | |
| 2564 LE32_CPU(attach->sequence); | |
| 2565 DEBUG_EMAIL(("%i\n", attach->sequence)); | |
| 2566 break; | |
| 2567 case 0x3A00: // PR_ACCOUNT | |
| 2568 DEBUG_EMAIL(("Contact's Account name - ")); | |
| 2569 MALLOC_CONTACT(item); | |
| 2570 LIST_COPY(item->contact->account_name, (char*)); | |
| 2571 DEBUG_EMAIL(("%s\n", item->contact->account_name)); | |
| 2572 break; | |
| 2573 case 0x3A01: // PR_ALTERNATE_RECIPIENT | |
| 2574 DEBUG_EMAIL(("Contact Alternate Recipient - NOT PROCESSED\n")); | |
| 2575 break; | |
| 2576 case 0x3A02: // PR_CALLBACK_TELEPHONE_NUMBER | |
| 2577 DEBUG_EMAIL(("Callback telephone number - ")); | |
| 2578 MALLOC_CONTACT(item); | |
| 2579 LIST_COPY(item->contact->callback_phone, (char*)); | |
| 2580 DEBUG_EMAIL(("%s\n", item->contact->callback_phone)); | |
| 2581 break; | |
| 2582 case 0x3A03: // PR_CONVERSION_PROHIBITED | |
| 2583 DEBUG_EMAIL(("Message Conversion Prohibited - ")); | |
| 2584 MALLOC_EMAIL(item); | |
| 51 | 2585 if (*(int16_t*)list->items[x]->data) { |
| 43 | 2586 DEBUG_EMAIL(("True\n")); |
| 2587 item->email->conversion_prohib = 1; | |
| 2588 } else { | |
| 2589 DEBUG_EMAIL(("False\n")); | |
| 2590 item->email->conversion_prohib = 0; | |
| 2591 } | |
| 2592 break; | |
| 2593 case 0x3A05: // PR_GENERATION suffix | |
| 2594 DEBUG_EMAIL(("Contacts Suffix - ")); | |
| 2595 MALLOC_CONTACT(item); | |
| 2596 LIST_COPY(item->contact->suffix, (char*)); | |
| 2597 DEBUG_EMAIL(("%s\n", item->contact->suffix)); | |
| 2598 break; | |
| 2599 case 0x3A06: // PR_GIVEN_NAME Contact's first name | |
| 2600 DEBUG_EMAIL(("Contacts First Name - ")); | |
| 2601 MALLOC_CONTACT(item); | |
| 2602 LIST_COPY(item->contact->first_name, (char*)); | |
| 2603 DEBUG_EMAIL(("%s\n", item->contact->first_name)); | |
| 2604 break; | |
| 2605 case 0x3A07: // PR_GOVERNMENT_ID_NUMBER | |
| 2606 DEBUG_EMAIL(("Contacts Government ID Number - ")); | |
| 2607 MALLOC_CONTACT(item); | |
| 2608 LIST_COPY(item->contact->gov_id, (char*)); | |
| 2609 DEBUG_EMAIL(("%s\n", item->contact->gov_id)); | |
| 2610 break; | |
| 2611 case 0x3A08: // PR_BUSINESS_TELEPHONE_NUMBER | |
| 2612 DEBUG_EMAIL(("Business Telephone Number - ")); | |
| 2613 MALLOC_CONTACT(item); | |
| 2614 LIST_COPY(item->contact->business_phone, (char*)); | |
| 2615 DEBUG_EMAIL(("%s\n", item->contact->business_phone)); | |
| 2616 break; | |
| 2617 case 0x3A09: // PR_HOME_TELEPHONE_NUMBER | |
| 2618 DEBUG_EMAIL(("Home Telephone Number - ")); | |
| 2619 MALLOC_CONTACT(item); | |
| 2620 LIST_COPY(item->contact->home_phone, (char*)); | |
| 2621 DEBUG_EMAIL(("%s\n", item->contact->home_phone)); | |
| 2622 break; | |
| 2623 case 0x3A0A: // PR_INITIALS Contact's Initials | |
| 2624 DEBUG_EMAIL(("Contacts Initials - ")); | |
| 2625 MALLOC_CONTACT(item); | |
| 2626 LIST_COPY(item->contact->initials, (char*)); | |
| 2627 DEBUG_EMAIL(("%s\n", item->contact->initials)); | |
| 2628 break; | |
| 2629 case 0x3A0B: // PR_KEYWORD | |
| 2630 DEBUG_EMAIL(("Keyword - ")); | |
| 2631 MALLOC_CONTACT(item); | |
| 2632 LIST_COPY(item->contact->keyword, (char*)); | |
| 2633 DEBUG_EMAIL(("%s\n", item->contact->keyword)); | |
| 2634 break; | |
| 2635 case 0x3A0C: // PR_LANGUAGE | |
| 2636 DEBUG_EMAIL(("Contact's Language - ")); | |
| 2637 MALLOC_CONTACT(item); | |
| 2638 LIST_COPY(item->contact->language, (char*)); | |
| 2639 DEBUG_EMAIL(("%s\n", item->contact->language)); | |
| 2640 break; | |
| 2641 case 0x3A0D: // PR_LOCATION | |
| 2642 DEBUG_EMAIL(("Contact's Location - ")); | |
| 2643 MALLOC_CONTACT(item); | |
| 2644 LIST_COPY(item->contact->location, (char*)); | |
| 2645 DEBUG_EMAIL(("%s\n", item->contact->location)); | |
| 2646 break; | |
| 2647 case 0x3A0E: // PR_MAIL_PERMISSION - Can the recipient receive and send email | |
| 2648 DEBUG_EMAIL(("Mail Permission - ")); | |
| 2649 MALLOC_CONTACT(item); | |
| 51 | 2650 if (*(int16_t*)list->items[x]->data) { |
| 43 | 2651 DEBUG_EMAIL(("True\n")); |
| 2652 item->contact->mail_permission = 1; | |
| 2653 } else { | |
| 2654 DEBUG_EMAIL(("False\n")); | |
| 2655 item->contact->mail_permission = 0; | |
| 2656 } | |
| 2657 break; | |
| 2658 case 0x3A0F: // PR_MHS_COMMON_NAME | |
| 2659 DEBUG_EMAIL(("MHS Common Name - ")); | |
| 2660 MALLOC_EMAIL(item); | |
| 2661 LIST_COPY(item->email->common_name, (char*)); | |
| 2662 DEBUG_EMAIL(("%s\n", item->email->common_name)); | |
| 2663 break; | |
| 2664 case 0x3A10: // PR_ORGANIZATIONAL_ID_NUMBER | |
| 2665 DEBUG_EMAIL(("Organizational ID # - ")); | |
| 2666 MALLOC_CONTACT(item); | |
| 2667 LIST_COPY(item->contact->org_id, (char*)); | |
| 2668 DEBUG_EMAIL(("%s\n", item->contact->org_id)); | |
| 2669 break; | |
| 2670 case 0x3A11: // PR_SURNAME Contact's Surname | |
| 2671 DEBUG_EMAIL(("Contacts Surname - ")); | |
| 2672 MALLOC_CONTACT(item); | |
| 2673 LIST_COPY(item->contact->surname, (char*)); | |
| 2674 DEBUG_EMAIL(("%s\n", item->contact->surname)); | |
| 2675 break; | |
| 2676 case 0x3A12: // PR_ORIGINAL_ENTRY_ID | |
| 2677 DEBUG_EMAIL(("Original Entry ID - NOT PROCESSED\n")); | |
| 2678 break; | |
| 2679 case 0x3A13: // PR_ORIGINAL_DISPLAY_NAME | |
| 2680 DEBUG_EMAIL(("Original Display Name - NOT PROCESSED\n")); | |
| 2681 break; | |
| 2682 case 0x3A14: // PR_ORIGINAL_SEARCH_KEY | |
| 2683 DEBUG_EMAIL(("Original Search Key - NOT PROCESSED\n")); | |
| 2684 break; | |
| 2685 case 0x3A15: // PR_POSTAL_ADDRESS | |
| 2686 DEBUG_EMAIL(("Default Postal Address - ")); | |
| 2687 MALLOC_CONTACT(item); | |
| 2688 LIST_COPY(item->contact->def_postal_address, (char*)); | |
| 2689 DEBUG_EMAIL(("%s\n", item->contact->def_postal_address)); | |
| 2690 break; | |
| 2691 case 0x3A16: // PR_COMPANY_NAME | |
| 2692 DEBUG_EMAIL(("Company Name - ")); | |
| 2693 MALLOC_CONTACT(item); | |
| 2694 LIST_COPY(item->contact->company_name, (char*)); | |
| 2695 DEBUG_EMAIL(("%s\n", item->contact->company_name)); | |
| 2696 break; | |
| 2697 case 0x3A17: // PR_TITLE - Job Title | |
| 2698 DEBUG_EMAIL(("Job Title - ")); | |
| 2699 MALLOC_CONTACT(item); | |
| 2700 LIST_COPY(item->contact->job_title, (char*)); | |
| 2701 DEBUG_EMAIL(("%s\n", item->contact->job_title)); | |
| 2702 break; | |
| 2703 case 0x3A18: // PR_DEPARTMENT_NAME | |
| 2704 DEBUG_EMAIL(("Department Name - ")); | |
| 2705 MALLOC_CONTACT(item); | |
| 2706 LIST_COPY(item->contact->department, (char*)); | |
| 2707 DEBUG_EMAIL(("%s\n", item->contact->department)); | |
| 2708 break; | |
| 2709 case 0x3A19: // PR_OFFICE_LOCATION | |
| 2710 DEBUG_EMAIL(("Office Location - ")); | |
| 2711 MALLOC_CONTACT(item); | |
| 2712 LIST_COPY(item->contact->office_loc, (char*)); | |
| 2713 DEBUG_EMAIL(("%s\n", item->contact->office_loc)); | |
| 2714 break; | |
| 2715 case 0x3A1A: // PR_PRIMARY_TELEPHONE_NUMBER | |
| 2716 DEBUG_EMAIL(("Primary Telephone - ")); | |
| 2717 MALLOC_CONTACT(item); | |
| 2718 LIST_COPY(item->contact->primary_phone, (char*)); | |
| 2719 DEBUG_EMAIL(("%s\n", item->contact->primary_phone)); | |
| 2720 break; | |
| 2721 case 0x3A1B: // PR_BUSINESS2_TELEPHONE_NUMBER | |
| 2722 DEBUG_EMAIL(("Business Phone Number 2 - ")); | |
| 2723 MALLOC_CONTACT(item); | |
| 2724 LIST_COPY(item->contact->business_phone2, (char*)); | |
| 2725 DEBUG_EMAIL(("%s\n", item->contact->business_phone2)); | |
| 2726 break; | |
| 2727 case 0x3A1C: // PR_MOBILE_TELEPHONE_NUMBER | |
| 2728 DEBUG_EMAIL(("Mobile Phone Number - ")); | |
| 2729 MALLOC_CONTACT(item); | |
| 2730 LIST_COPY(item->contact->mobile_phone, (char*)); | |
| 2731 DEBUG_EMAIL(("%s\n", item->contact->mobile_phone)); | |
| 2732 break; | |
| 2733 case 0x3A1D: // PR_RADIO_TELEPHONE_NUMBER | |
| 2734 DEBUG_EMAIL(("Radio Phone Number - ")); | |
| 2735 MALLOC_CONTACT(item); | |
| 2736 LIST_COPY(item->contact->radio_phone, (char*)); | |
| 2737 DEBUG_EMAIL(("%s\n", item->contact->radio_phone)); | |
| 2738 break; | |
| 2739 case 0x3A1E: // PR_CAR_TELEPHONE_NUMBER | |
| 2740 DEBUG_EMAIL(("Car Phone Number - ")); | |
| 2741 MALLOC_CONTACT(item); | |
| 2742 LIST_COPY(item->contact->car_phone, (char*)); | |
| 2743 DEBUG_EMAIL(("%s\n", item->contact->car_phone)); | |
| 2744 break; | |
| 2745 case 0x3A1F: // PR_OTHER_TELEPHONE_NUMBER | |
| 2746 DEBUG_EMAIL(("Other Phone Number - ")); | |
| 2747 MALLOC_CONTACT(item); | |
| 2748 LIST_COPY(item->contact->other_phone, (char*)); | |
| 2749 DEBUG_EMAIL(("%s\n", item->contact->other_phone)); | |
| 2750 break; | |
| 2751 case 0x3A20: // PR_TRANSMITTABLE_DISPLAY_NAME | |
| 2752 DEBUG_EMAIL(("Transmittable Display Name - ")); | |
| 2753 MALLOC_CONTACT(item); | |
| 2754 LIST_COPY(item->contact->transmittable_display_name, (char*)); | |
| 2755 DEBUG_EMAIL(("%s\n", item->contact->transmittable_display_name)); | |
| 2756 break; | |
| 2757 case 0x3A21: // PR_PAGER_TELEPHONE_NUMBER | |
| 2758 DEBUG_EMAIL(("Pager Phone Number - ")); | |
| 2759 MALLOC_CONTACT(item); | |
| 2760 LIST_COPY(item->contact->pager_phone, (char*)); | |
| 2761 DEBUG_EMAIL(("%s\n", item->contact->pager_phone)); | |
| 2762 break; | |
| 2763 case 0x3A22: // PR_USER_CERTIFICATE | |
| 2764 DEBUG_EMAIL(("User Certificate - NOT PROCESSED")); | |
| 2765 break; | |
| 2766 case 0x3A23: // PR_PRIMARY_FAX_NUMBER | |
| 2767 DEBUG_EMAIL(("Primary Fax Number - ")); | |
| 2768 MALLOC_CONTACT(item); | |
| 2769 LIST_COPY(item->contact->primary_fax, (char*)); | |
| 2770 DEBUG_EMAIL(("%s\n", item->contact->primary_fax)); | |
| 2771 break; | |
| 2772 case 0x3A24: // PR_BUSINESS_FAX_NUMBER | |
| 2773 DEBUG_EMAIL(("Business Fax Number - ")); | |
| 2774 MALLOC_CONTACT(item); | |
| 2775 LIST_COPY(item->contact->business_fax, (char*)); | |
| 2776 DEBUG_EMAIL(("%s\n", item->contact->business_fax)); | |
| 2777 break; | |
| 2778 case 0x3A25: // PR_HOME_FAX_NUMBER | |
| 2779 DEBUG_EMAIL(("Home Fax Number - ")); | |
| 2780 MALLOC_CONTACT(item); | |
| 2781 LIST_COPY(item->contact->home_fax, (char*)); | |
| 2782 DEBUG_EMAIL(("%s\n", item->contact->home_fax)); | |
| 2783 break; | |
| 2784 case 0x3A26: // PR_BUSINESS_ADDRESS_COUNTRY | |
| 2785 DEBUG_EMAIL(("Business Address Country - ")); | |
| 2786 MALLOC_CONTACT(item); | |
| 2787 LIST_COPY(item->contact->business_country, (char*)); | |
| 2788 DEBUG_EMAIL(("%s\n", item->contact->business_country)); | |
| 2789 break; | |
| 2790 case 0x3A27: // PR_BUSINESS_ADDRESS_CITY | |
| 2791 DEBUG_EMAIL(("Business Address City - ")); | |
| 2792 MALLOC_CONTACT(item); | |
| 2793 LIST_COPY(item->contact->business_city, (char*)); | |
| 2794 DEBUG_EMAIL(("%s\n", item->contact->business_city)); | |
| 2795 break; | |
| 2796 case 0x3A28: // PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE | |
| 2797 DEBUG_EMAIL(("Business Address State - ")); | |
| 2798 MALLOC_CONTACT(item); | |
| 2799 LIST_COPY(item->contact->business_state, (char*)); | |
| 2800 DEBUG_EMAIL(("%s\n", item->contact->business_state)); | |
| 2801 break; | |
| 2802 case 0x3A29: // PR_BUSINESS_ADDRESS_STREET | |
| 2803 DEBUG_EMAIL(("Business Address Street - ")); | |
| 2804 MALLOC_CONTACT(item); | |
| 2805 LIST_COPY(item->contact->business_street, (char*)); | |
| 2806 DEBUG_EMAIL(("%s\n", item->contact->business_street)); | |
| 2807 break; | |
| 2808 case 0x3A2A: // PR_BUSINESS_POSTAL_CODE | |
| 2809 DEBUG_EMAIL(("Business Postal Code - ")); | |
| 2810 MALLOC_CONTACT(item); | |
| 2811 LIST_COPY(item->contact->business_postal_code, (char*)); | |
| 2812 DEBUG_EMAIL(("%s\n", item->contact->business_postal_code)); | |
| 2813 break; | |
| 2814 case 0x3A2B: // PR_BUSINESS_PO_BOX | |
| 2815 DEBUG_EMAIL(("Business PO Box - ")); | |
| 2816 MALLOC_CONTACT(item); | |
| 2817 LIST_COPY(item->contact->business_po_box, (char*)); | |
| 2818 DEBUG_EMAIL(("%s\n", item->contact->business_po_box)); | |
| 2819 break; | |
| 2820 case 0x3A2C: // PR_TELEX_NUMBER | |
| 2821 DEBUG_EMAIL(("Telex Number - ")); | |
| 2822 MALLOC_CONTACT(item); | |
| 2823 LIST_COPY(item->contact->telex, (char*)); | |
| 2824 DEBUG_EMAIL(("%s\n", item->contact->telex)); | |
| 2825 break; | |
| 2826 case 0x3A2D: // PR_ISDN_NUMBER | |
| 2827 DEBUG_EMAIL(("ISDN Number - ")); | |
| 2828 MALLOC_CONTACT(item); | |
| 2829 LIST_COPY(item->contact->isdn_phone, (char*)); | |
| 2830 DEBUG_EMAIL(("%s\n", item->contact->isdn_phone)); | |
| 2831 break; | |
| 2832 case 0x3A2E: // PR_ASSISTANT_TELEPHONE_NUMBER | |
| 2833 DEBUG_EMAIL(("Assistant Phone Number - ")); | |
| 2834 MALLOC_CONTACT(item); | |
| 2835 LIST_COPY(item->contact->assistant_phone, (char*)); | |
| 2836 DEBUG_EMAIL(("%s\n", item->contact->assistant_phone)); | |
| 2837 break; | |
| 2838 case 0x3A2F: // PR_HOME2_TELEPHONE_NUMBER | |
| 2839 DEBUG_EMAIL(("Home Phone 2 - ")); | |
| 2840 MALLOC_CONTACT(item); | |
| 2841 LIST_COPY(item->contact->home_phone2, (char*)); | |
| 2842 DEBUG_EMAIL(("%s\n", item->contact->home_phone2)); | |
| 2843 break; | |
| 2844 case 0x3A30: // PR_ASSISTANT | |
| 2845 DEBUG_EMAIL(("Assistant's Name - ")); | |
| 2846 MALLOC_CONTACT(item); | |
| 2847 LIST_COPY(item->contact->assistant_name, (char*)); | |
| 2848 DEBUG_EMAIL(("%s\n", item->contact->assistant_name)); | |
| 2849 break; | |
| 2850 case 0x3A40: // PR_SEND_RICH_INFO | |
| 2851 DEBUG_EMAIL(("Can receive Rich Text - ")); | |
| 2852 MALLOC_CONTACT(item); | |
| 51 | 2853 if (*(int16_t*)list->items[x]->data) { |
| 43 | 2854 DEBUG_EMAIL(("True\n")); |
| 2855 item->contact->rich_text = 1; | |
| 2856 } else { | |
| 2857 DEBUG_EMAIL(("False\n")); | |
| 2858 item->contact->rich_text = 0; | |
| 2859 } | |
| 2860 break; | |
| 2861 case 0x3A41: // PR_WEDDING_ANNIVERSARY | |
| 2862 DEBUG_EMAIL(("Wedding Anniversary - ")); | |
| 2863 MALLOC_CONTACT(item); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
2864 LIST_COPY_TIME(item->contact->wedding_anniversary); |
| 43 | 2865 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->contact->wedding_anniversary))); |
| 2866 break; | |
| 2867 case 0x3A42: // PR_BIRTHDAY | |
| 2868 DEBUG_EMAIL(("Birthday - ")); | |
| 2869 MALLOC_CONTACT(item); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
2870 LIST_COPY_TIME(item->contact->birthday); |
| 43 | 2871 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->contact->birthday))); |
| 2872 break; | |
| 2873 case 0x3A43: // PR_HOBBIES | |
| 2874 DEBUG_EMAIL(("Hobbies - ")); | |
| 2875 MALLOC_CONTACT(item); | |
| 2876 LIST_COPY(item->contact->hobbies, (char*)); | |
| 2877 DEBUG_EMAIL(("%s\n", item->contact->hobbies)); | |
| 2878 break; | |
| 2879 case 0x3A44: // PR_MIDDLE_NAME | |
| 2880 DEBUG_EMAIL(("Middle Name - ")); | |
| 2881 MALLOC_CONTACT(item); | |
| 2882 LIST_COPY(item->contact->middle_name, (char*)); | |
| 2883 DEBUG_EMAIL(("%s\n", item->contact->middle_name)); | |
| 2884 break; | |
| 2885 case 0x3A45: // PR_DISPLAY_NAME_PREFIX | |
| 2886 DEBUG_EMAIL(("Display Name Prefix (Title) - ")); | |
| 2887 MALLOC_CONTACT(item); | |
| 2888 LIST_COPY(item->contact->display_name_prefix, (char*)); | |
| 2889 DEBUG_EMAIL(("%s\n", item->contact->display_name_prefix)); | |
| 2890 break; | |
| 2891 case 0x3A46: // PR_PROFESSION | |
| 2892 DEBUG_EMAIL(("Profession - ")); | |
| 2893 MALLOC_CONTACT(item); | |
| 2894 LIST_COPY(item->contact->profession, (char*)); | |
| 2895 DEBUG_EMAIL(("%s\n", item->contact->profession)); | |
| 2896 break; | |
| 2897 case 0x3A47: // PR_PREFERRED_BY_NAME | |
| 2898 DEBUG_EMAIL(("Preferred By Name - ")); | |
| 2899 MALLOC_CONTACT(item); | |
| 2900 LIST_COPY(item->contact->pref_name, (char*)); | |
| 2901 DEBUG_EMAIL(("%s\n", item->contact->pref_name)); | |
| 2902 break; | |
| 2903 case 0x3A48: // PR_SPOUSE_NAME | |
| 2904 DEBUG_EMAIL(("Spouse's Name - ")); | |
| 2905 MALLOC_CONTACT(item); | |
| 2906 LIST_COPY(item->contact->spouse_name, (char*)); | |
| 2907 DEBUG_EMAIL(("%s\n", item->contact->spouse_name)); | |
| 2908 break; | |
| 2909 case 0x3A49: // PR_COMPUTER_NETWORK_NAME | |
| 2910 DEBUG_EMAIL(("Computer Network Name - ")); | |
| 2911 MALLOC_CONTACT(item); | |
| 2912 LIST_COPY(item->contact->computer_name, (char*)); | |
| 2913 DEBUG_EMAIL(("%s\n", item->contact->computer_name)); | |
| 2914 break; | |
| 2915 case 0x3A4A: // PR_CUSTOMER_ID | |
| 2916 DEBUG_EMAIL(("Customer ID - ")); | |
| 2917 MALLOC_CONTACT(item); | |
| 2918 LIST_COPY(item->contact->customer_id, (char*)); | |
| 2919 DEBUG_EMAIL(("%s\n", item->contact->customer_id)); | |
| 2920 break; | |
| 2921 case 0x3A4B: // PR_TTYTDD_PHONE_NUMBER | |
| 2922 DEBUG_EMAIL(("TTY/TDD Phone - ")); | |
| 2923 MALLOC_CONTACT(item); | |
| 2924 LIST_COPY(item->contact->ttytdd_phone, (char*)); | |
| 2925 DEBUG_EMAIL(("%s\n", item->contact->ttytdd_phone)); | |
| 2926 break; | |
| 2927 case 0x3A4C: // PR_FTP_SITE | |
| 2928 DEBUG_EMAIL(("Ftp Site - ")); | |
| 2929 MALLOC_CONTACT(item); | |
| 2930 LIST_COPY(item->contact->ftp_site, (char*)); | |
| 2931 DEBUG_EMAIL(("%s\n", item->contact->ftp_site)); | |
| 2932 break; | |
| 2933 case 0x3A4D: // PR_GENDER | |
| 2934 DEBUG_EMAIL(("Gender - ")); | |
| 2935 MALLOC_CONTACT(item); | |
| 51 | 2936 memcpy(&item->contact->gender, list->items[x]->data, sizeof(item->contact->gender)); |
| 43 | 2937 LE16_CPU(item->contact->gender); |
| 2938 switch(item->contact->gender) { | |
| 2939 case 0: | |
| 2940 DEBUG_EMAIL(("Unspecified\n")); | |
| 2941 break; | |
| 2942 case 1: | |
| 2943 DEBUG_EMAIL(("Female\n")); | |
| 2944 break; | |
| 2945 case 2: | |
| 2946 DEBUG_EMAIL(("Male\n")); | |
| 2947 break; | |
| 2948 default: | |
| 2949 DEBUG_EMAIL(("Error processing\n")); | |
| 2950 } | |
| 2951 break; | |
| 2952 case 0x3A4E: // PR_MANAGER_NAME | |
| 2953 DEBUG_EMAIL(("Manager's Name - ")); | |
| 2954 MALLOC_CONTACT(item); | |
| 2955 LIST_COPY(item->contact->manager_name, (char*)); | |
| 2956 DEBUG_EMAIL(("%s\n", item->contact->manager_name)); | |
| 2957 break; | |
| 2958 case 0x3A4F: // PR_NICKNAME | |
| 2959 DEBUG_EMAIL(("Nickname - ")); | |
| 2960 MALLOC_CONTACT(item); | |
| 2961 LIST_COPY(item->contact->nickname, (char*)); | |
| 2962 DEBUG_EMAIL(("%s\n", item->contact->nickname)); | |
| 2963 break; | |
| 2964 case 0x3A50: // PR_PERSONAL_HOME_PAGE | |
| 2965 DEBUG_EMAIL(("Personal Home Page - ")); | |
| 2966 MALLOC_CONTACT(item); | |
| 2967 LIST_COPY(item->contact->personal_homepage, (char*)); | |
| 2968 DEBUG_EMAIL(("%s\n", item->contact->personal_homepage)); | |
| 2969 break; | |
| 2970 case 0x3A51: // PR_BUSINESS_HOME_PAGE | |
| 2971 DEBUG_EMAIL(("Business Home Page - ")); | |
| 2972 MALLOC_CONTACT(item); | |
| 2973 LIST_COPY(item->contact->business_homepage, (char*)); | |
| 2974 DEBUG_EMAIL(("%s\n", item->contact->business_homepage)); | |
| 2975 break; | |
| 2976 case 0x3A57: // PR_COMPANY_MAIN_PHONE_NUMBER | |
| 2977 DEBUG_EMAIL(("Company Main Phone - ")); | |
| 2978 MALLOC_CONTACT(item); | |
| 2979 LIST_COPY(item->contact->company_main_phone, (char*)); | |
| 2980 DEBUG_EMAIL(("%s\n", item->contact->company_main_phone)); | |
| 2981 break; | |
| 2982 case 0x3A58: // PR_CHILDRENS_NAMES | |
| 2983 DEBUG_EMAIL(("Children's Names - NOT PROCESSED\n")); | |
| 2984 break; | |
| 2985 case 0x3A59: // PR_HOME_ADDRESS_CITY | |
| 2986 DEBUG_EMAIL(("Home Address City - ")); | |
| 2987 MALLOC_CONTACT(item); | |
| 2988 LIST_COPY(item->contact->home_city, (char*)); | |
| 2989 DEBUG_EMAIL(("%s\n", item->contact->home_city)); | |
| 2990 break; | |
| 2991 case 0x3A5A: // PR_HOME_ADDRESS_COUNTRY | |
| 2992 DEBUG_EMAIL(("Home Address Country - ")); | |
| 2993 MALLOC_CONTACT(item); | |
| 2994 LIST_COPY(item->contact->home_country, (char*)); | |
| 2995 DEBUG_EMAIL(("%s\n", item->contact->home_country)); | |
| 2996 break; | |
| 2997 case 0x3A5B: // PR_HOME_ADDRESS_POSTAL_CODE | |
| 2998 DEBUG_EMAIL(("Home Address Postal Code - ")); | |
| 2999 MALLOC_CONTACT(item); | |
| 3000 LIST_COPY(item->contact->home_postal_code, (char*)); | |
| 3001 DEBUG_EMAIL(("%s\n", item->contact->home_postal_code)); | |
| 3002 break; | |
| 3003 case 0x3A5C: // PR_HOME_ADDRESS_STATE_OR_PROVINCE | |
| 3004 DEBUG_EMAIL(("Home Address State or Province - ")); | |
| 3005 MALLOC_CONTACT(item); | |
| 3006 LIST_COPY(item->contact->home_state, (char*)); | |
| 3007 DEBUG_EMAIL(("%s\n", item->contact->home_state)); | |
| 3008 break; | |
| 3009 case 0x3A5D: // PR_HOME_ADDRESS_STREET | |
| 3010 DEBUG_EMAIL(("Home Address Street - ")); | |
| 3011 MALLOC_CONTACT(item); | |
| 3012 LIST_COPY(item->contact->home_street, (char*)); | |
| 3013 DEBUG_EMAIL(("%s\n", item->contact->home_street)); | |
| 3014 break; | |
| 3015 case 0x3A5E: // PR_HOME_ADDRESS_POST_OFFICE_BOX | |
| 3016 DEBUG_EMAIL(("Home Address Post Office Box - ")); | |
| 3017 MALLOC_CONTACT(item); | |
| 3018 LIST_COPY(item->contact->home_po_box, (char*)); | |
| 3019 DEBUG_EMAIL(("%s\n", item->contact->home_po_box)); | |
| 3020 break; | |
| 3021 case 0x3A5F: // PR_OTHER_ADDRESS_CITY | |
| 3022 DEBUG_EMAIL(("Other Address City - ")); | |
| 3023 MALLOC_CONTACT(item); | |
| 3024 LIST_COPY(item->contact->other_city, (char*)); | |
| 3025 DEBUG_EMAIL(("%s\n", item->contact->other_city)); | |
| 3026 break; | |
| 3027 case 0x3A60: // PR_OTHER_ADDRESS_COUNTRY | |
| 3028 DEBUG_EMAIL(("Other Address Country - ")); | |
| 3029 MALLOC_CONTACT(item); | |
| 3030 LIST_COPY(item->contact->other_country, (char*)); | |
| 3031 DEBUG_EMAIL(("%s\n", item->contact->other_country)); | |
| 3032 break; | |
| 3033 case 0x3A61: // PR_OTHER_ADDRESS_POSTAL_CODE | |
| 3034 DEBUG_EMAIL(("Other Address Postal Code - ")); | |
| 3035 MALLOC_CONTACT(item); | |
| 3036 LIST_COPY(item->contact->other_postal_code, (char*)); | |
| 3037 DEBUG_EMAIL(("%s\n", item->contact->other_postal_code)); | |
| 3038 break; | |
| 3039 case 0x3A62: // PR_OTHER_ADDRESS_STATE_OR_PROVINCE | |
| 3040 DEBUG_EMAIL(("Other Address State - ")); | |
| 3041 MALLOC_CONTACT(item); | |
| 3042 LIST_COPY(item->contact->other_state, (char*)); | |
| 3043 DEBUG_EMAIL(("%s\n", item->contact->other_state)); | |
| 3044 break; | |
| 3045 case 0x3A63: // PR_OTHER_ADDRESS_STREET | |
| 3046 DEBUG_EMAIL(("Other Address Street - ")); | |
| 3047 MALLOC_CONTACT(item); | |
| 3048 LIST_COPY(item->contact->other_street, (char*)); | |
| 3049 DEBUG_EMAIL(("%s\n", item->contact->other_street)); | |
| 3050 break; | |
| 3051 case 0x3A64: // PR_OTHER_ADDRESS_POST_OFFICE_BOX | |
| 3052 DEBUG_EMAIL(("Other Address Post Office box - ")); | |
| 3053 MALLOC_CONTACT(item); | |
| 3054 LIST_COPY(item->contact->other_po_box, (char*)); | |
| 3055 DEBUG_EMAIL(("%s\n", item->contact->other_po_box)); | |
| 3056 break; | |
| 3057 case 0x65E3: // Entry ID? | |
| 3058 DEBUG_EMAIL(("Entry ID - ")); | |
| 3059 item->record_key = (char*) xmalloc(16+1); | |
| 3060 memcpy(item->record_key, &(list->items[x]->data[1]), 16); //skip first byte | |
| 3061 item->record_key[16]='\0'; | |
| 3062 item->record_key_size=16; | |
| 3063 DEBUG_EMAIL_HEXPRINT((char*)item->record_key, 16); | |
| 3064 break; | |
| 3065 case 0x67F2: // ID2 value of the attachments proper record | |
| 3066 DEBUG_EMAIL(("Attachment ID2 value - ")); | |
| 46 | 3067 if (attach) { |
| 3068 uint32_t tempid; | |
| 43 | 3069 MOVE_NEXT(attach); |
| 46 | 3070 memcpy(&(tempid), list->items[x]->data, sizeof(tempid)); |
| 3071 LE32_CPU(tempid); | |
| 3072 attach->id2_val = tempid; | |
| 3073 DEBUG_EMAIL(("%#llx\n", attach->id2_val)); | |
| 43 | 3074 } else { |
| 3075 DEBUG_EMAIL(("NOT AN ATTACHMENT: %#x\n", list->items[x]->id)); | |
| 3076 } | |
| 3077 break; | |
| 3078 case 0x67FF: // Extra Property Identifier (Password CheckSum) | |
| 3079 DEBUG_EMAIL(("Password checksum [0x67FF] - ")); | |
| 3080 MALLOC_MESSAGESTORE(item); | |
| 51 | 3081 memcpy(&(item->message_store->pwd_chksum), list->items[x]->data, sizeof(item->message_store->pwd_chksum)); |
| 43 | 3082 DEBUG_EMAIL(("%#x\n", item->message_store->pwd_chksum)); |
| 3083 break; | |
| 3084 case 0x6F02: // Secure HTML Body | |
| 3085 DEBUG_EMAIL(("Secure HTML Body - ")); | |
| 3086 MALLOC_EMAIL(item); | |
| 3087 LIST_COPY(item->email->encrypted_htmlbody, (char*)); | |
| 3088 item->email->encrypted_htmlbody_size = list->items[x]->size; | |
| 3089 DEBUG_EMAIL(("Not Printed\n")); | |
| 3090 break; | |
| 3091 case 0x6F04: // Secure Text Body | |
| 3092 DEBUG_EMAIL(("Secure Text Body - ")); | |
| 3093 MALLOC_EMAIL(item); | |
| 3094 LIST_COPY(item->email->encrypted_body, (char*)); | |
| 3095 item->email->encrypted_body_size = list->items[x]->size; | |
| 3096 DEBUG_EMAIL(("Not Printed\n")); | |
| 3097 break; | |
| 3098 case 0x7C07: // top of folders ENTRYID | |
| 3099 DEBUG_EMAIL(("Top of folders RecID [0x7c07] - ")); | |
| 3100 MALLOC_MESSAGESTORE(item); | |
| 3101 item->message_store->top_of_folder = (pst_entryid*) xmalloc(sizeof(pst_entryid)); | |
| 3102 memcpy(item->message_store->top_of_folder, list->items[x]->data, sizeof(pst_entryid)); | |
| 3103 LE32_CPU(item->message_store->top_of_folder->u1); | |
| 3104 LE32_CPU(item->message_store->top_of_folder->id); | |
| 3105 DEBUG_EMAIL_HEXPRINT((char*)item->message_store->top_of_folder->entryid, 16); | |
| 3106 break; | |
| 3107 case 0x8005: // Contact's Fullname | |
| 3108 DEBUG_EMAIL(("Contact Fullname - ")); | |
| 3109 MALLOC_CONTACT(item); | |
| 3110 LIST_COPY(item->contact->fullname, (char*)); | |
| 3111 DEBUG_EMAIL(("%s\n", item->contact->fullname)); | |
| 3112 break; | |
| 3113 case 0x801A: // Full Home Address | |
| 3114 DEBUG_EMAIL(("Home Address - ")); | |
| 3115 MALLOC_CONTACT(item); | |
| 3116 LIST_COPY(item->contact->home_address, (char*)); | |
| 3117 DEBUG_EMAIL(("%s\n", item->contact->home_address)); | |
| 3118 break; | |
| 3119 case 0x801B: // Full Business Address | |
| 3120 DEBUG_EMAIL(("Business Address - ")); | |
| 3121 MALLOC_CONTACT(item); | |
| 3122 LIST_COPY(item->contact->business_address, (char*)); | |
| 3123 DEBUG_EMAIL(("%s\n", item->contact->business_address)); | |
| 3124 break; | |
| 3125 case 0x801C: // Full Other Address | |
| 3126 DEBUG_EMAIL(("Other Address - ")); | |
| 3127 MALLOC_CONTACT(item); | |
| 3128 LIST_COPY(item->contact->other_address, (char*)); | |
| 3129 DEBUG_EMAIL(("%s\n", item->contact->other_address)); | |
| 3130 break; | |
| 51 | 3131 case 0x8045: // Work address street |
| 3132 DEBUG_EMAIL(("Work address street - ")); | |
| 3133 MALLOC_CONTACT(item); | |
| 3134 LIST_COPY(item->contact->work_address_street, (char*)); | |
| 3135 DEBUG_EMAIL(("%s\n", item->contact->work_address_street)); | |
| 3136 break; | |
| 3137 case 0x8046: // Work address city | |
| 3138 DEBUG_EMAIL(("Work address city - ")); | |
| 3139 MALLOC_CONTACT(item); | |
| 3140 LIST_COPY(item->contact->work_address_city, (char*)); | |
| 3141 DEBUG_EMAIL(("%s\n", item->contact->work_address_city)); | |
| 3142 break; | |
| 3143 case 0x8047: // Work address state | |
| 3144 DEBUG_EMAIL(("Work address state - ")); | |
| 3145 MALLOC_CONTACT(item); | |
| 3146 LIST_COPY(item->contact->work_address_state, (char*)); | |
| 3147 DEBUG_EMAIL(("%s\n", item->contact->work_address_state)); | |
| 3148 break; | |
| 3149 case 0x8048: // Work address postalcode | |
| 3150 DEBUG_EMAIL(("Work address postalcode - ")); | |
| 3151 MALLOC_CONTACT(item); | |
| 3152 LIST_COPY(item->contact->work_address_postalcode, (char*)); | |
| 3153 DEBUG_EMAIL(("%s\n", item->contact->work_address_postalcode)); | |
| 3154 break; | |
| 3155 case 0x8049: // Work address country | |
| 3156 DEBUG_EMAIL(("Work address country - ")); | |
| 3157 MALLOC_CONTACT(item); | |
| 3158 LIST_COPY(item->contact->work_address_country, (char*)); | |
| 3159 DEBUG_EMAIL(("%s\n", item->contact->work_address_country)); | |
| 3160 break; | |
| 3161 case 0x804A: // Work address postofficebox | |
| 3162 DEBUG_EMAIL(("Work address postofficebox - ")); | |
| 3163 MALLOC_CONTACT(item); | |
| 3164 LIST_COPY(item->contact->work_address_postofficebox, (char*)); | |
| 3165 DEBUG_EMAIL(("%s\n", item->contact->work_address_postofficebox)); | |
| 3166 break; | |
| 43 | 3167 case 0x8082: // Email Address 1 Transport |
| 3168 DEBUG_EMAIL(("Email Address 1 Transport - ")); | |
| 3169 MALLOC_CONTACT(item); | |
| 3170 LIST_COPY(item->contact->address1_transport, (char*)); | |
| 3171 DEBUG_EMAIL(("|%s|\n", item->contact->address1_transport)); | |
| 3172 break; | |
| 3173 case 0x8083: // Email Address 1 Address | |
| 3174 DEBUG_EMAIL(("Email Address 1 Address - ")); | |
| 3175 MALLOC_CONTACT(item); | |
| 3176 LIST_COPY(item->contact->address1, (char*)); | |
| 3177 DEBUG_EMAIL(("|%s|\n", item->contact->address1)); | |
| 3178 break; | |
| 3179 case 0x8084: // Email Address 1 Description | |
| 3180 DEBUG_EMAIL(("Email Address 1 Description - ")); | |
| 3181 MALLOC_CONTACT(item); | |
| 3182 LIST_COPY(item->contact->address1_desc, (char*)); | |
| 3183 DEBUG_EMAIL(("|%s|\n", item->contact->address1_desc)); | |
| 3184 break; | |
| 3185 case 0x8085: // Email Address 1 Record | |
| 3186 DEBUG_EMAIL(("Email Address 1 Record - ")); | |
| 3187 MALLOC_CONTACT(item); | |
| 3188 LIST_COPY(item->contact->address1a, (char*)); | |
| 3189 DEBUG_EMAIL(("|%s|\n", item->contact->address1a)); | |
| 3190 break; | |
| 3191 case 0x8092: // Email Address 2 Transport | |
| 3192 DEBUG_EMAIL(("Email Address 2 Transport - ")); | |
| 3193 MALLOC_CONTACT(item); | |
| 3194 LIST_COPY(item->contact->address2_transport, (char*)); | |
| 3195 DEBUG_EMAIL(("|%s|\n", item->contact->address2_transport)); | |
| 3196 break; | |
| 3197 case 0x8093: // Email Address 2 Address | |
| 3198 DEBUG_EMAIL(("Email Address 2 Address - ")); | |
| 3199 MALLOC_CONTACT(item); | |
| 3200 LIST_COPY(item->contact->address2, (char*)); | |
| 3201 DEBUG_EMAIL(("|%s|\n", item->contact->address2)); | |
| 3202 break; | |
| 3203 case 0x8094: // Email Address 2 Description | |
| 3204 DEBUG_EMAIL (("Email Address 2 Description - ")); | |
| 3205 MALLOC_CONTACT(item); | |
| 3206 LIST_COPY(item->contact->address2_desc, (char*)); | |
| 3207 DEBUG_EMAIL(("|%s|\n", item->contact->address2_desc)); | |
| 3208 break; | |
| 3209 case 0x8095: // Email Address 2 Record | |
| 3210 DEBUG_EMAIL(("Email Address 2 Record - ")); | |
| 3211 MALLOC_CONTACT(item); | |
| 3212 LIST_COPY(item->contact->address2a, (char*)); | |
| 3213 DEBUG_EMAIL(("|%s|\n", item->contact->address2a)); | |
| 3214 break; | |
| 3215 case 0x80A2: // Email Address 3 Transport | |
| 3216 DEBUG_EMAIL (("Email Address 3 Transport - ")); | |
| 3217 MALLOC_CONTACT(item); | |
| 3218 LIST_COPY(item->contact->address3_transport, (char*)); | |
| 3219 DEBUG_EMAIL(("|%s|\n", item->contact->address3_transport)); | |
| 3220 break; | |
| 3221 case 0x80A3: // Email Address 3 Address | |
| 3222 DEBUG_EMAIL(("Email Address 3 Address - ")); | |
| 3223 MALLOC_CONTACT(item); | |
| 3224 LIST_COPY(item->contact->address3, (char*)); | |
| 3225 DEBUG_EMAIL(("|%s|\n", item->contact->address3)); | |
| 3226 break; | |
| 3227 case 0x80A4: // Email Address 3 Description | |
| 3228 DEBUG_EMAIL(("Email Address 3 Description - ")); | |
| 3229 MALLOC_CONTACT(item); | |
| 3230 LIST_COPY(item->contact->address3_desc, (char*)); | |
| 3231 DEBUG_EMAIL(("|%s|\n", item->contact->address3_desc)); | |
| 3232 break; | |
| 3233 case 0x80A5: // Email Address 3 Record | |
| 3234 DEBUG_EMAIL(("Email Address 3 Record - ")); | |
| 3235 MALLOC_CONTACT(item); | |
| 3236 LIST_COPY(item->contact->address3a, (char*)); | |
| 3237 DEBUG_EMAIL(("|%s|\n", item->contact->address3a)); | |
| 3238 break; | |
| 3239 case 0x80D8: // Internet Free/Busy | |
| 3240 DEBUG_EMAIL(("Internet Free/Busy - ")); | |
| 3241 MALLOC_CONTACT(item); | |
| 3242 LIST_COPY(item->contact->free_busy_address, (char*)); | |
| 3243 DEBUG_EMAIL(("%s\n", item->contact->free_busy_address)); | |
| 3244 break; | |
| 3245 case 0x8205: // Show on Free/Busy as | |
| 3246 // 0: Free | |
| 3247 // 1: Tentative | |
| 3248 // 2: Busy | |
| 3249 // 3: Out Of Office | |
| 3250 DEBUG_EMAIL(("Appointment shows as - ")); | |
| 3251 MALLOC_APPOINTMENT(item); | |
| 3252 memcpy(&(item->appointment->showas), list->items[x]->data, sizeof(item->appointment->showas)); | |
| 3253 LE32_CPU(item->appointment->showas); | |
| 3254 switch (item->appointment->showas) { | |
| 3255 case PST_FREEBUSY_FREE: | |
| 3256 DEBUG_EMAIL(("Free\n")); break; | |
| 3257 case PST_FREEBUSY_TENTATIVE: | |
| 3258 DEBUG_EMAIL(("Tentative\n")); break; | |
| 3259 case PST_FREEBUSY_BUSY: | |
| 3260 DEBUG_EMAIL(("Busy\n")); break; | |
| 3261 case PST_FREEBUSY_OUT_OF_OFFICE: | |
| 3262 DEBUG_EMAIL(("Out Of Office\n")); break; | |
| 3263 default: | |
| 3264 DEBUG_EMAIL(("Unknown Value: %d\n", item->appointment->showas)); break; | |
| 3265 } | |
| 3266 break; | |
| 3267 case 0x8208: // Location of an appointment | |
| 3268 DEBUG_EMAIL(("Appointment Location - ")); | |
| 3269 MALLOC_APPOINTMENT(item); | |
| 3270 LIST_COPY(item->appointment->location, (char*)); | |
| 3271 DEBUG_EMAIL(("%s\n", item->appointment->location)); | |
| 3272 break; | |
| 50 | 3273 case 0x820d: // Appointment start |
| 3274 DEBUG_EMAIL(("Appointment Date Start - ")); | |
| 3275 MALLOC_APPOINTMENT(item); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
3276 LIST_COPY_TIME(item->appointment->start); |
| 50 | 3277 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->appointment->start))); |
| 3278 break; | |
| 3279 case 0x820e: // Appointment end | |
| 3280 DEBUG_EMAIL(("Appointment Date End - ")); | |
| 3281 MALLOC_APPOINTMENT(item); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
3282 LIST_COPY_TIME(item->appointment->end); |
| 50 | 3283 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->appointment->end))); |
| 3284 break; | |
| 43 | 3285 case 0x8214: // Label for an appointment |
| 3286 DEBUG_EMAIL(("Label for appointment - ")); | |
| 3287 MALLOC_APPOINTMENT(item); | |
| 3288 memcpy(&(item->appointment->label), list->items[x]->data, sizeof(item->appointment->label)); | |
| 3289 LE32_CPU(item->appointment->label); | |
| 3290 switch (item->appointment->label) { | |
| 3291 case PST_APP_LABEL_NONE: | |
| 3292 DEBUG_EMAIL(("None\n")); break; | |
| 3293 case PST_APP_LABEL_IMPORTANT: | |
| 3294 DEBUG_EMAIL(("Important\n")); break; | |
| 3295 case PST_APP_LABEL_BUSINESS: | |
| 3296 DEBUG_EMAIL(("Business\n")); break; | |
| 3297 case PST_APP_LABEL_PERSONAL: | |
| 3298 DEBUG_EMAIL(("Personal\n")); break; | |
| 3299 case PST_APP_LABEL_VACATION: | |
| 3300 DEBUG_EMAIL(("Vacation\n")); break; | |
| 3301 case PST_APP_LABEL_MUST_ATTEND: | |
| 3302 DEBUG_EMAIL(("Must Attend\n")); break; | |
| 3303 case PST_APP_LABEL_TRAVEL_REQ: | |
| 3304 DEBUG_EMAIL(("Travel Required\n")); break; | |
| 3305 case PST_APP_LABEL_NEEDS_PREP: | |
| 3306 DEBUG_EMAIL(("Needs Preparation\n")); break; | |
| 3307 case PST_APP_LABEL_BIRTHDAY: | |
| 3308 DEBUG_EMAIL(("Birthday\n")); break; | |
| 3309 case PST_APP_LABEL_ANNIVERSARY: | |
| 3310 DEBUG_EMAIL(("Anniversary\n")); break; | |
| 3311 case PST_APP_LABEL_PHONE_CALL: | |
| 3312 DEBUG_EMAIL(("Phone Call\n")); break; | |
| 3313 } | |
| 3314 break; | |
| 3315 case 0x8215: // All day appointment flag | |
| 3316 DEBUG_EMAIL(("All day flag - ")); | |
| 3317 MALLOC_APPOINTMENT(item); | |
| 51 | 3318 if (*(int16_t*)list->items[x]->data) { |
| 43 | 3319 DEBUG_EMAIL(("True\n")); |
| 3320 item->appointment->all_day = 1; | |
| 3321 } else { | |
| 3322 DEBUG_EMAIL(("False\n")); | |
| 3323 item->appointment->all_day = 0; | |
| 3324 } | |
| 3325 break; | |
| 50 | 3326 case 0x8231: // Recurrence type |
| 3327 // 1: Daily | |
| 3328 // 2: Weekly | |
| 3329 // 3: Monthly | |
| 3330 // 4: Yearly | |
| 3331 DEBUG_EMAIL(("Appointment reccurs - ")); | |
| 3332 MALLOC_APPOINTMENT(item); | |
| 3333 memcpy(&(item->appointment->recurrence_type), list->items[x]->data, sizeof(item->appointment->recurrence_type)); | |
| 3334 LE32_CPU(item->appointment->recurrence_type); | |
| 3335 switch (item->appointment->recurrence_type) { | |
| 3336 case PST_APP_RECUR_DAILY: | |
| 3337 DEBUG_EMAIL(("Daily\n")); break; | |
| 3338 case PST_APP_RECUR_WEEKLY: | |
| 3339 DEBUG_EMAIL(("Weekly\n")); break; | |
| 3340 case PST_APP_RECUR_MONTHLY: | |
| 3341 DEBUG_EMAIL(("Monthly\n")); break; | |
| 3342 case PST_APP_RECUR_YEARLY: | |
| 3343 DEBUG_EMAIL(("Yearly\n")); break; | |
| 3344 default: | |
| 3345 DEBUG_EMAIL(("Unknown Value: %d\n", item->appointment->recurrence_type)); break; | |
| 3346 } | |
| 3347 break; | |
| 3348 case 0x8232: // Recurrence description | |
| 3349 DEBUG_EMAIL(("Appointment recurrence description - ")); | |
| 3350 MALLOC_APPOINTMENT(item); | |
| 3351 LIST_COPY(item->appointment->recurrence, (char*)); | |
| 3352 DEBUG_EMAIL(("%s\n", item->appointment->recurrence)); | |
| 3353 break; | |
| 43 | 3354 case 0x8234: // TimeZone as String |
| 3355 DEBUG_EMAIL(("TimeZone of times - ")); | |
| 3356 MALLOC_APPOINTMENT(item); | |
| 3357 LIST_COPY(item->appointment->timezonestring, (char*)); | |
| 3358 DEBUG_EMAIL(("%s\n", item->appointment->timezonestring)); | |
| 3359 break; | |
| 50 | 3360 case 0x8235: // Recurrence start date |
| 3361 DEBUG_EMAIL(("Recurrence Start Date - ")); | |
| 3362 MALLOC_APPOINTMENT(item); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
3363 LIST_COPY_TIME(item->appointment->recurrence_start); |
| 50 | 3364 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->appointment->recurrence_start))); |
| 3365 break; | |
| 3366 case 0x8236: // Recurrence end date | |
| 3367 DEBUG_EMAIL(("Recurrence End Date - ")); | |
| 43 | 3368 MALLOC_APPOINTMENT(item); |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
3369 LIST_COPY_TIME(item->appointment->recurrence_end); |
| 50 | 3370 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->appointment->recurrence_end))); |
| 3371 break; | |
| 3372 case 0x8501: // Reminder minutes before appointment start | |
| 3373 DEBUG_EMAIL(("Alarm minutes - ")); | |
| 3374 MALLOC_APPOINTMENT(item); | |
| 3375 memcpy(&(item->appointment->alarm_minutes), list->items[x]->data, sizeof(item->appointment->alarm_minutes)); | |
| 3376 LE32_CPU(item->appointment->alarm_minutes); | |
| 3377 DEBUG_EMAIL(("%i\n", item->appointment->alarm_minutes)); | |
| 3378 break; | |
| 3379 case 0x8503: // Reminder alarm | |
| 3380 DEBUG_EMAIL(("Reminder alarm - ")); | |
| 43 | 3381 MALLOC_APPOINTMENT(item); |
| 51 | 3382 if (*(int16_t*)list->items[x]->data) { |
| 50 | 3383 DEBUG_EMAIL(("True\n")); |
| 3384 item->appointment->alarm = 1; | |
| 3385 } else { | |
| 3386 DEBUG_EMAIL(("False\n")); | |
| 3387 item->appointment->alarm = 0; | |
| 3388 } | |
| 3389 break; | |
| 51 | 3390 case 0x8516: // Common start |
| 3391 DEBUG_EMAIL(("Common Start Date - ")); | |
| 43 | 3392 DEBUG_EMAIL(("%s\n", fileTimeToAscii((FILETIME*)list->items[x]->data))); |
| 3393 break; | |
| 51 | 3394 case 0x8517: // Common end |
| 3395 DEBUG_EMAIL(("Common End Date - ")); | |
| 43 | 3396 DEBUG_EMAIL(("%s\n", fileTimeToAscii((FILETIME*)list->items[x]->data))); |
| 3397 break; | |
| 50 | 3398 case 0x851f: // Play reminder sound filename |
| 3399 DEBUG_EMAIL(("Appointment reminder sound filename - ")); | |
| 3400 MALLOC_APPOINTMENT(item); | |
| 3401 LIST_COPY(item->appointment->alarm_filename, (char*)); | |
| 3402 DEBUG_EMAIL(("%s\n", item->appointment->alarm_filename)); | |
| 3403 break; | |
| 43 | 3404 case 0x8530: // Followup |
| 3405 DEBUG_EMAIL(("Followup String - ")); | |
| 3406 MALLOC_CONTACT(item); | |
| 3407 LIST_COPY(item->contact->followup, (char*)); | |
| 3408 DEBUG_EMAIL(("%s\n", item->contact->followup)); | |
| 3409 break; | |
| 3410 case 0x8534: // Mileage | |
| 3411 DEBUG_EMAIL(("Mileage - ")); | |
| 3412 MALLOC_CONTACT(item); | |
| 3413 LIST_COPY(item->contact->mileage, (char*)); | |
| 3414 DEBUG_EMAIL(("%s\n", item->contact->mileage)); | |
| 3415 break; | |
| 3416 case 0x8535: // Billing Information | |
| 3417 DEBUG_EMAIL(("Billing Information - ")); | |
| 3418 MALLOC_CONTACT(item); | |
| 3419 LIST_COPY(item->contact->billing_information, (char*)); | |
| 3420 DEBUG_EMAIL(("%s\n", item->contact->billing_information)); | |
| 3421 break; | |
| 3422 case 0x8554: // Outlook Version | |
| 3423 DEBUG_EMAIL(("Outlook Version - ")); | |
| 3424 LIST_COPY(item->outlook_version, (char*)); | |
| 3425 DEBUG_EMAIL(("%s\n", item->outlook_version)); | |
| 3426 break; | |
| 3427 case 0x8560: // Appointment Reminder Time | |
| 3428 DEBUG_EMAIL(("Appointment Reminder Time - ")); | |
| 3429 MALLOC_APPOINTMENT(item); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
3430 LIST_COPY_TIME(item->appointment->reminder); |
| 43 | 3431 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->appointment->reminder))); |
| 3432 break; | |
| 3433 case 0x8700: // Journal Type | |
| 3434 DEBUG_EMAIL(("Journal Entry Type - ")); | |
| 3435 MALLOC_JOURNAL(item); | |
| 3436 LIST_COPY(item->journal->type, (char*)); | |
| 3437 DEBUG_EMAIL(("%s\n", item->journal->type)); | |
| 3438 break; | |
| 3439 case 0x8706: // Journal Start date/time | |
| 3440 DEBUG_EMAIL(("Start Timestamp - ")); | |
| 3441 MALLOC_JOURNAL(item); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
3442 LIST_COPY_TIME(item->journal->start); |
| 43 | 3443 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->journal->start))); |
| 3444 break; | |
| 3445 case 0x8708: // Journal End date/time | |
| 3446 DEBUG_EMAIL(("End Timestamp - ")); | |
| 3447 MALLOC_JOURNAL(item); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
3448 LIST_COPY_TIME(item->journal->end); |
| 43 | 3449 DEBUG_EMAIL(("%s\n", fileTimeToAscii(item->journal->end))); |
| 3450 break; | |
| 3451 case 0x8712: // Title? | |
| 3452 DEBUG_EMAIL(("Journal Entry Type - ")); | |
| 3453 MALLOC_JOURNAL(item); | |
| 3454 LIST_COPY(item->journal->type, (char*)); | |
| 3455 DEBUG_EMAIL(("%s\n", item->journal->type)); | |
| 3456 break; | |
| 3457 default: | |
| 51 | 3458 if (list->items[x]->type == (uint32_t)0x0002) { |
| 3459 DEBUG_EMAIL(("Unknown type %#x 16bit int = %hi\n", list->items[x]->id, | |
| 3460 *(int16_t*)list->items[x]->data)); | |
| 3461 | |
| 3462 } else if (list->items[x]->type == (uint32_t)0x0003) { | |
| 3463 DEBUG_EMAIL(("Unknown type %#x 32bit int = %i\n", list->items[x]->id, | |
| 3464 *(int32_t*)list->items[x]->data)); | |
| 3465 | |
| 3466 } else if (list->items[x]->type == (uint32_t)0x0004) { | |
| 3467 DEBUG_EMAIL(("Unknown type %#x 4-byte floating [size = %#x]\n", list->items[x]->id, | |
| 3468 list->items[x]->size)); | |
| 3469 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3470 | |
| 3471 } else if (list->items[x]->type == (uint32_t)0x0005) { | |
| 3472 DEBUG_EMAIL(("Unknown type %#x double floating [size = %#x]\n", list->items[x]->id, | |
| 3473 list->items[x]->size)); | |
| 3474 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3475 | |
| 3476 } else if (list->items[x]->type == (uint32_t)0x0006) { | |
| 3477 DEBUG_EMAIL(("Unknown type %#x signed 64bit int = %lli\n", list->items[x]->id, | |
| 3478 *(int64_t*)list->items[x]->data)); | |
| 3479 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3480 | |
| 3481 } else if (list->items[x]->type == (uint32_t)0x0007) { | |
| 3482 DEBUG_EMAIL(("Unknown type %#x application time [size = %#x]\n", list->items[x]->id, | |
| 3483 list->items[x]->size)); | |
| 3484 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3485 | |
| 3486 } else if (list->items[x]->type == (uint32_t)0x000a) { | |
| 3487 DEBUG_EMAIL(("Unknown type %#x 32bit error value = %i\n", list->items[x]->id, | |
| 3488 *(int32_t*)list->items[x]->data)); | |
| 3489 | |
| 3490 } else if (list->items[x]->type == (uint32_t)0x000b) { | |
| 3491 DEBUG_EMAIL(("Unknown type %#x 16bit boolean = %s [%hi]\n", list->items[x]->id, | |
| 3492 (*((int16_t*)list->items[x]->data)!=0?"True":"False"), | |
| 3493 *((int16_t*)list->items[x]->data))); | |
| 3494 | |
| 3495 } else if (list->items[x]->type == (uint32_t)0x000d) { | |
| 3496 DEBUG_EMAIL(("Unknown type %#x Embedded object [size = %#x]\n", list->items[x]->id, | |
| 3497 list->items[x]->size)); | |
| 3498 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3499 | |
| 3500 } else if (list->items[x]->type == (uint32_t)0x0014) { | |
| 3501 DEBUG_EMAIL(("Unknown type %#x signed 64bit int = %lli\n", list->items[x]->id, | |
| 3502 *(int64_t*)list->items[x]->data)); | |
| 43 | 3503 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); |
| 51 | 3504 |
| 3505 } else if (list->items[x]->type == (uint32_t)0x001e) { | |
| 3506 DEBUG_EMAIL(("Unknown type %#x String Data = \"%s\"\n", list->items[x]->id, | |
| 3507 list->items[x]->data)); | |
| 3508 | |
| 3509 } else if (list->items[x]->type == (uint32_t)0x001f) { | |
| 3510 DEBUG_EMAIL(("Unknown type %#x Unicode String Data [size = %#x]\n", list->items[x]->id, | |
| 3511 list->items[x]->size)); | |
| 3512 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3513 | |
| 3514 } else if (list->items[x]->type == (uint32_t)0x0040) { | |
| 3515 DEBUG_EMAIL(("Unknown type %#x Date = \"%s\"\n", list->items[x]->id, | |
| 3516 fileTimeToAscii((FILETIME*)list->items[x]->data))); | |
| 3517 | |
| 3518 } else if (list->items[x]->type == (uint32_t)0x0048) { | |
| 3519 DEBUG_EMAIL(("Unknown type %#x OLE GUID [size = %#x]\n", list->items[x]->id, | |
| 3520 list->items[x]->size)); | |
| 3521 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3522 | |
| 3523 } else if (list->items[x]->type == (uint32_t)0x0102) { | |
| 3524 DEBUG_EMAIL(("Unknown type %#x Binary Data [size = %#x]\n", list->items[x]->id, | |
| 3525 list->items[x]->size)); | |
| 3526 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3527 | |
| 3528 } else if (list->items[x]->type == (uint32_t)0x1003) { | |
| 3529 DEBUG_EMAIL(("Unknown type %#x Array of 32 bit values [size = %#x]\n", list->items[x]->id, | |
| 3530 list->items[x]->size)); | |
| 3531 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3532 | |
| 3533 } else if (list->items[x]->type == (uint32_t)0x1014) { | |
| 3534 DEBUG_EMAIL(("Unknown type %#x Array of 64 bit values [siize = %#x]\n", list->items[x]->id, | |
| 3535 list->items[x]->size)); | |
| 3536 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3537 | |
| 47 | 3538 } else if (list->items[x]->type == (uint32_t)0x101E) { |
| 51 | 3539 DEBUG_EMAIL(("Unknown type %#x Array of Strings [size = %#x]\n", list->items[x]->id, |
| 3540 list->items[x]->size)); | |
| 3541 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3542 | |
| 3543 } else if (list->items[x]->type == (uint32_t)0x1102) { | |
| 3544 DEBUG_EMAIL(("Unknown type %#x Array of binary data blobs [size = %#x]\n", list->items[x]->id, | |
| 3545 list->items[x]->size)); | |
| 3546 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 3547 | |
| 43 | 3548 } else { |
| 51 | 3549 DEBUG_EMAIL(("Unknown type %#x Not Printable [%#x]\n", list->items[x]->id, |
| 3550 list->items[x]->type)); | |
| 3551 DEBUG_HEXDUMP(list->items[x]->data, list->items[x]->size); | |
| 43 | 3552 } |
| 51 | 3553 |
| 43 | 3554 if (list->items[x]->data) { |
| 3555 free(list->items[x]->data); | |
| 3556 list->items[x]->data = NULL; | |
| 3557 } | |
| 3558 } | |
| 3559 x++; | |
| 3560 } | |
| 3561 x = 0; | |
| 3562 list = list->next; | |
| 3563 next = 1; | |
| 3564 } | |
| 3565 DEBUG_RET(); | |
| 3566 return 0; | |
| 16 | 3567 } |
| 3568 | |
| 3569 | |
| 46 | 3570 void pst_free_list(pst_num_array *list) { |
| 43 | 3571 pst_num_array *l; |
| 46 | 3572 DEBUG_ENT("pst_free_list"); |
| 43 | 3573 while (list) { |
| 3574 if (list->items) { | |
| 3575 int32_t x; | |
| 3576 for (x=0; x < list->orig_count; x++) { | |
| 3577 if (list->items[x]) { | |
| 3578 if (list->items[x]->data) free(list->items[x]->data); | |
| 3579 free(list->items[x]); | |
| 3580 } | |
| 3581 } | |
| 3582 free(list->items); | |
| 3583 } | |
| 3584 l = list; | |
| 3585 list = list->next; | |
| 3586 free (l); | |
| 3587 } | |
| 3588 DEBUG_RET(); | |
| 16 | 3589 } |
| 3590 | |
| 3591 | |
| 46 | 3592 void pst_free_id2(pst_index2_ll * head) { |
| 43 | 3593 pst_index2_ll *t; |
| 46 | 3594 DEBUG_ENT("pst_free_id2"); |
| 43 | 3595 while (head) { |
| 3596 t = head->next; | |
| 3597 free (head); | |
| 3598 head = t; | |
| 3599 } | |
| 3600 DEBUG_RET(); | |
| 16 | 3601 } |
| 3602 | |
| 3603 | |
| 46 | 3604 void pst_free_id (pst_index_ll *head) { |
| 43 | 3605 pst_index_ll *t; |
| 46 | 3606 DEBUG_ENT("pst_free_id"); |
| 43 | 3607 while (head) { |
| 3608 t = head->next; | |
| 3609 free(head); | |
| 3610 head = t; | |
| 3611 } | |
| 3612 DEBUG_RET(); | |
| 16 | 3613 } |
| 3614 | |
| 3615 | |
| 46 | 3616 void pst_free_desc (pst_desc_ll *head) { |
| 43 | 3617 pst_desc_ll *t; |
| 46 | 3618 DEBUG_ENT("pst_free_desc"); |
| 43 | 3619 while (head) { |
| 3620 while (head->child) { | |
| 3621 head = head->child; | |
| 3622 } | |
| 3623 | |
| 3624 // point t to the next item | |
| 3625 t = head->next; | |
| 3626 if (!t && head->parent) { | |
| 3627 t = head->parent; | |
| 3628 t->child = NULL; // set the child to NULL so we don't come back here again! | |
| 3629 } | |
| 3630 | |
| 3631 if (head) free(head); | |
| 3632 else DIE(("head is NULL")); | |
| 3633 | |
| 3634 head = t; | |
| 3635 } | |
| 3636 DEBUG_RET(); | |
| 16 | 3637 } |
| 3638 | |
| 3639 | |
| 46 | 3640 void pst_free_xattrib(pst_x_attrib_ll *x) { |
| 43 | 3641 pst_x_attrib_ll *t; |
| 46 | 3642 DEBUG_ENT("pst_free_xattrib"); |
| 43 | 3643 while (x) { |
| 3644 if (x->data) free(x->data); | |
| 3645 t = x->next; | |
| 3646 free(x); | |
| 3647 x = t; | |
| 3648 } | |
| 3649 DEBUG_RET(); | |
| 16 | 3650 } |
| 3651 | |
| 3652 | |
| 46 | 3653 pst_index2_ll * pst_build_id2(pst_file *pf, pst_index_ll* list, pst_index2_ll* head_ptr) { |
| 43 | 3654 pst_block_header block_head; |
| 3655 pst_index2_ll *head = NULL, *tail = NULL; | |
| 46 | 3656 uint16_t x = 0; |
| 3657 char *b_ptr = NULL; | |
| 43 | 3658 char *buf = NULL; |
| 3659 pst_id2_assoc id2_rec; | |
| 3660 pst_index_ll *i_ptr = NULL; | |
| 3661 pst_index2_ll *i2_ptr = NULL; | |
| 46 | 3662 DEBUG_ENT("pst_build_id2"); |
| 43 | 3663 |
| 3664 if (head_ptr) { | |
| 3665 head = head_ptr; | |
| 3666 while (head_ptr) head_ptr = (tail = head_ptr)->next; | |
| 3667 } | |
| 51 | 3668 if (pst_read_block_size(pf, list->offset, list->size, &buf) < list->size) { |
| 43 | 3669 //an error occured in block read |
| 3670 WARN(("block read error occured. offset = %#llx, size = %#llx\n", list->offset, list->size)); | |
| 3671 if (buf) free(buf); | |
| 3672 DEBUG_RET(); | |
| 3673 return NULL; | |
| 3674 } | |
| 3675 DEBUG_HEXDUMPC(buf, list->size, 16); | |
| 3676 | |
| 3677 memcpy(&block_head, buf, sizeof(block_head)); | |
| 3678 LE16_CPU(block_head.type); | |
| 3679 LE16_CPU(block_head.count); | |
| 3680 | |
| 46 | 3681 if (block_head.type != (uint16_t)0x0002) { // some sort of constant? |
| 47 | 3682 WARN(("Unknown constant [%#hx] at start of id2 values [offset %#llx].\n", block_head.type, list->offset)); |
| 43 | 3683 if (buf) free(buf); |
| 3684 DEBUG_RET(); | |
| 3685 return NULL; | |
| 3686 } | |
| 3687 | |
| 46 | 3688 DEBUG_INDEX(("ID %#llx is likely to be a description record. Count is %i (offset %#llx)\n", |
| 43 | 3689 list->id, block_head.count, list->offset)); |
| 3690 x = 0; | |
| 46 | 3691 b_ptr = buf + ((pf->do_read64) ? 0x08 : 0x04); |
| 43 | 3692 while (x < block_head.count) { |
| 46 | 3693 b_ptr += pst_decode_assoc(pf, &id2_rec, b_ptr); |
| 48 | 3694 DEBUG_INDEX(("\tid2 = %#x, id = %#llx, table2 = %#llx\n", id2_rec.id2, id2_rec.id, id2_rec.table2)); |
| 46 | 3695 if ((i_ptr = pst_getID(pf, id2_rec.id)) == NULL) { |
| 3696 DEBUG_WARN(("\t\t%#llx - Not Found\n", id2_rec.id)); | |
| 43 | 3697 } else { |
| 46 | 3698 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 | 3699 // add it to the linked list |
| 3700 i2_ptr = (pst_index2_ll*) xmalloc(sizeof(pst_index2_ll)); | |
| 3701 i2_ptr->id2 = id2_rec.id2; | |
| 3702 i2_ptr->id = i_ptr; | |
| 3703 i2_ptr->next = NULL; | |
| 3704 if (!head) head = i2_ptr; | |
| 3705 if (tail) tail->next = i2_ptr; | |
| 3706 tail = i2_ptr; | |
| 3707 if (id2_rec.table2 != 0) { | |
| 46 | 3708 if ((i_ptr = pst_getID(pf, id2_rec.table2)) == NULL) { |
| 43 | 3709 DEBUG_WARN(("\tTable2 [%#x] not found\n", id2_rec.table2)); |
| 3710 } | |
| 3711 else { | |
| 3712 DEBUG_INDEX(("\tGoing deeper for table2 [%#x]\n", id2_rec.table2)); | |
| 46 | 3713 if ((i2_ptr = pst_build_id2(pf, i_ptr, head))) { |
| 3714 // DEBUG_INDEX(("pst_build_id2(): \t\tAdding new list onto end of current\n")); | |
| 43 | 3715 // if (!head) |
| 3716 // head = i2_ptr; | |
| 3717 // if (tail) | |
| 3718 // tail->next = i2_ptr; | |
| 3719 // while (i2_ptr->next) | |
| 3720 // i2_ptr = i2_ptr->next; | |
| 3721 // tail = i2_ptr; | |
| 3722 } | |
| 3723 // need to re-establish tail | |
| 3724 DEBUG_INDEX(("Returned from depth\n")); | |
| 3725 if (tail) { | |
| 3726 while (tail->next) tail = tail->next; | |
| 3727 } | |
| 3728 } | |
| 3729 } | |
| 3730 } | |
| 3731 x++; | |
| 3732 } | |
| 3733 if (buf) free (buf); | |
| 3734 DEBUG_RET(); | |
| 3735 return head; | |
| 16 | 3736 } |
| 3737 | |
| 3738 | |
| 46 | 3739 void pst_freeItem(pst_item *item) { |
| 43 | 3740 pst_item_attach *t; |
| 3741 pst_item_extra_field *et; | |
| 3742 | |
| 46 | 3743 DEBUG_ENT("pst_freeItem"); |
| 43 | 3744 if (item) { |
| 3745 if (item->email) { | |
| 3746 SAFE_FREE(item->email->arrival_date); | |
| 3747 SAFE_FREE(item->email->body); | |
| 3748 SAFE_FREE(item->email->cc_address); | |
|
59
7d5c637aaafb
General cleanup and code fixes.
Carl Byington <carl@five-ten-sg.com>
parents:
58
diff
changeset
|
3749 SAFE_FREE(item->email->bcc_address); |
| 43 | 3750 SAFE_FREE(item->email->common_name); |
| 3751 SAFE_FREE(item->email->encrypted_body); | |
| 3752 SAFE_FREE(item->email->encrypted_htmlbody); | |
| 3753 SAFE_FREE(item->email->header); | |
| 3754 SAFE_FREE(item->email->htmlbody); | |
| 3755 SAFE_FREE(item->email->in_reply_to); | |
| 3756 SAFE_FREE(item->email->messageid); | |
| 3757 SAFE_FREE(item->email->outlook_recipient); | |
| 3758 SAFE_FREE(item->email->outlook_recipient2); | |
| 3759 SAFE_FREE(item->email->outlook_sender); | |
| 3760 SAFE_FREE(item->email->outlook_sender_name); | |
| 3761 SAFE_FREE(item->email->outlook_sender2); | |
| 3762 SAFE_FREE(item->email->proc_subject); | |
| 3763 SAFE_FREE(item->email->recip_access); | |
| 3764 SAFE_FREE(item->email->recip_address); | |
| 3765 SAFE_FREE(item->email->recip2_access); | |
| 3766 SAFE_FREE(item->email->recip2_address); | |
| 3767 SAFE_FREE(item->email->reply_to); | |
| 3768 SAFE_FREE(item->email->rtf_body_tag); | |
| 3769 SAFE_FREE(item->email->rtf_compressed); | |
| 3770 SAFE_FREE(item->email->return_path_address); | |
| 3771 SAFE_FREE(item->email->sender_access); | |
| 3772 SAFE_FREE(item->email->sender_address); | |
| 3773 SAFE_FREE(item->email->sender2_access); | |
| 3774 SAFE_FREE(item->email->sender2_address); | |
| 3775 SAFE_FREE(item->email->sent_date); | |
| 3776 SAFE_FREE(item->email->sentmail_folder); | |
| 3777 SAFE_FREE(item->email->sentto_address); | |
| 3778 if (item->email->subject) | |
| 3779 SAFE_FREE(item->email->subject->subj); | |
| 3780 SAFE_FREE(item->email->subject); | |
| 3781 free(item->email); | |
| 3782 } | |
| 3783 if (item->folder) { | |
| 3784 free(item->folder); | |
| 3785 } | |
| 3786 if (item->message_store) { | |
| 51 | 3787 SAFE_FREE(item->message_store->top_of_personal_folder); |
| 3788 SAFE_FREE(item->message_store->default_outbox_folder); | |
| 43 | 3789 SAFE_FREE(item->message_store->deleted_items_folder); |
| 51 | 3790 SAFE_FREE(item->message_store->sent_items_folder); |
| 3791 SAFE_FREE(item->message_store->user_views_folder); | |
| 3792 SAFE_FREE(item->message_store->common_view_folder); | |
| 43 | 3793 SAFE_FREE(item->message_store->search_root_folder); |
| 3794 SAFE_FREE(item->message_store->top_of_folder); | |
| 3795 free(item->message_store); | |
| 3796 } | |
| 3797 if (item->contact) { | |
| 3798 SAFE_FREE(item->contact->access_method); | |
| 3799 SAFE_FREE(item->contact->account_name); | |
| 3800 SAFE_FREE(item->contact->address1); | |
| 3801 SAFE_FREE(item->contact->address1a); | |
| 3802 SAFE_FREE(item->contact->address1_desc); | |
| 3803 SAFE_FREE(item->contact->address1_transport); | |
| 3804 SAFE_FREE(item->contact->address2); | |
| 3805 SAFE_FREE(item->contact->address2a); | |
| 3806 SAFE_FREE(item->contact->address2_desc); | |
| 3807 SAFE_FREE(item->contact->address2_transport); | |
| 3808 SAFE_FREE(item->contact->address3); | |
| 3809 SAFE_FREE(item->contact->address3a); | |
| 3810 SAFE_FREE(item->contact->address3_desc); | |
| 3811 SAFE_FREE(item->contact->address3_transport); | |
| 3812 SAFE_FREE(item->contact->assistant_name); | |
| 3813 SAFE_FREE(item->contact->assistant_phone); | |
| 3814 SAFE_FREE(item->contact->billing_information); | |
| 3815 SAFE_FREE(item->contact->birthday); | |
| 3816 SAFE_FREE(item->contact->business_address); | |
| 3817 SAFE_FREE(item->contact->business_city); | |
| 3818 SAFE_FREE(item->contact->business_country); | |
| 3819 SAFE_FREE(item->contact->business_fax); | |
| 3820 SAFE_FREE(item->contact->business_homepage); | |
| 3821 SAFE_FREE(item->contact->business_phone); | |
| 3822 SAFE_FREE(item->contact->business_phone2); | |
| 3823 SAFE_FREE(item->contact->business_po_box); | |
| 3824 SAFE_FREE(item->contact->business_postal_code); | |
| 3825 SAFE_FREE(item->contact->business_state); | |
| 3826 SAFE_FREE(item->contact->business_street); | |
| 3827 SAFE_FREE(item->contact->callback_phone); | |
| 3828 SAFE_FREE(item->contact->car_phone); | |
| 3829 SAFE_FREE(item->contact->company_main_phone); | |
| 3830 SAFE_FREE(item->contact->company_name); | |
| 3831 SAFE_FREE(item->contact->computer_name); | |
| 3832 SAFE_FREE(item->contact->customer_id); | |
| 3833 SAFE_FREE(item->contact->def_postal_address); | |
| 3834 SAFE_FREE(item->contact->department); | |
| 3835 SAFE_FREE(item->contact->display_name_prefix); | |
| 3836 SAFE_FREE(item->contact->first_name); | |
| 3837 SAFE_FREE(item->contact->followup); | |
| 3838 SAFE_FREE(item->contact->free_busy_address); | |
| 3839 SAFE_FREE(item->contact->ftp_site); | |
| 3840 SAFE_FREE(item->contact->fullname); | |
| 3841 SAFE_FREE(item->contact->gov_id); | |
| 3842 SAFE_FREE(item->contact->hobbies); | |
| 3843 SAFE_FREE(item->contact->home_address); | |
| 3844 SAFE_FREE(item->contact->home_city); | |
| 3845 SAFE_FREE(item->contact->home_country); | |
| 3846 SAFE_FREE(item->contact->home_fax); | |
| 3847 SAFE_FREE(item->contact->home_po_box); | |
| 3848 SAFE_FREE(item->contact->home_phone); | |
| 3849 SAFE_FREE(item->contact->home_phone2); | |
| 3850 SAFE_FREE(item->contact->home_postal_code); | |
| 3851 SAFE_FREE(item->contact->home_state); | |
| 3852 SAFE_FREE(item->contact->home_street); | |
| 3853 SAFE_FREE(item->contact->initials); | |
| 3854 SAFE_FREE(item->contact->isdn_phone); | |
| 3855 SAFE_FREE(item->contact->job_title); | |
| 3856 SAFE_FREE(item->contact->keyword); | |
| 3857 SAFE_FREE(item->contact->language); | |
| 3858 SAFE_FREE(item->contact->location); | |
| 3859 SAFE_FREE(item->contact->manager_name); | |
| 3860 SAFE_FREE(item->contact->middle_name); | |
| 3861 SAFE_FREE(item->contact->mileage); | |
| 3862 SAFE_FREE(item->contact->mobile_phone); | |
| 3863 SAFE_FREE(item->contact->nickname); | |
| 3864 SAFE_FREE(item->contact->office_loc); | |
| 3865 SAFE_FREE(item->contact->org_id); | |
| 3866 SAFE_FREE(item->contact->other_address); | |
| 3867 SAFE_FREE(item->contact->other_city); | |
| 3868 SAFE_FREE(item->contact->other_country); | |
| 3869 SAFE_FREE(item->contact->other_phone); | |
| 3870 SAFE_FREE(item->contact->other_po_box); | |
| 3871 SAFE_FREE(item->contact->other_postal_code); | |
| 3872 SAFE_FREE(item->contact->other_state); | |
| 3873 SAFE_FREE(item->contact->other_street); | |
| 3874 SAFE_FREE(item->contact->pager_phone); | |
| 3875 SAFE_FREE(item->contact->personal_homepage); | |
| 3876 SAFE_FREE(item->contact->pref_name); | |
| 3877 SAFE_FREE(item->contact->primary_fax); | |
| 3878 SAFE_FREE(item->contact->primary_phone); | |
| 3879 SAFE_FREE(item->contact->profession); | |
| 3880 SAFE_FREE(item->contact->radio_phone); | |
| 3881 SAFE_FREE(item->contact->spouse_name); | |
| 3882 SAFE_FREE(item->contact->suffix); | |
| 3883 SAFE_FREE(item->contact->surname); | |
| 3884 SAFE_FREE(item->contact->telex); | |
| 3885 SAFE_FREE(item->contact->transmittable_display_name); | |
| 3886 SAFE_FREE(item->contact->ttytdd_phone); | |
| 3887 SAFE_FREE(item->contact->wedding_anniversary); | |
| 51 | 3888 SAFE_FREE(item->contact->work_address_street); |
| 3889 SAFE_FREE(item->contact->work_address_city); | |
| 3890 SAFE_FREE(item->contact->work_address_state); | |
| 3891 SAFE_FREE(item->contact->work_address_postalcode); | |
| 3892 SAFE_FREE(item->contact->work_address_country); | |
| 3893 SAFE_FREE(item->contact->work_address_postofficebox); | |
| 43 | 3894 free(item->contact); |
| 3895 } | |
| 3896 while (item->attach) { | |
| 3897 SAFE_FREE(item->attach->filename1); | |
| 3898 SAFE_FREE(item->attach->filename2); | |
| 3899 SAFE_FREE(item->attach->mimetype); | |
| 3900 SAFE_FREE(item->attach->data); | |
| 3901 t = item->attach->next; | |
| 3902 free(item->attach); | |
| 3903 item->attach = t; | |
| 3904 } | |
| 3905 while (item->extra_fields) { | |
| 3906 SAFE_FREE(item->extra_fields->field_name); | |
| 3907 SAFE_FREE(item->extra_fields->value); | |
| 3908 et = item->extra_fields->next; | |
| 3909 free(item->extra_fields); | |
| 3910 item->extra_fields = et; | |
| 3911 } | |
| 3912 if (item->journal) { | |
| 3913 SAFE_FREE(item->journal->end); | |
| 3914 SAFE_FREE(item->journal->start); | |
| 3915 SAFE_FREE(item->journal->type); | |
| 3916 free(item->journal); | |
| 3917 } | |
| 3918 if (item->appointment) { | |
| 3919 SAFE_FREE(item->appointment->location); | |
| 3920 SAFE_FREE(item->appointment->reminder); | |
| 50 | 3921 SAFE_FREE(item->appointment->alarm_filename); |
| 43 | 3922 SAFE_FREE(item->appointment->start); |
| 3923 SAFE_FREE(item->appointment->end); | |
| 3924 SAFE_FREE(item->appointment->timezonestring); | |
| 50 | 3925 SAFE_FREE(item->appointment->recurrence); |
| 3926 SAFE_FREE(item->appointment->recurrence_start); | |
| 3927 SAFE_FREE(item->appointment->recurrence_end); | |
| 43 | 3928 free(item->appointment); |
| 3929 } | |
| 3930 SAFE_FREE(item->ascii_type); | |
| 3931 SAFE_FREE(item->comment); | |
| 3932 SAFE_FREE(item->create_date); | |
| 3933 SAFE_FREE(item->file_as); | |
| 3934 SAFE_FREE(item->modify_date); | |
| 3935 SAFE_FREE(item->outlook_version); | |
| 3936 SAFE_FREE(item->record_key); | |
| 3937 free(item); | |
| 3938 } | |
| 3939 DEBUG_RET(); | |
| 16 | 3940 } |
| 3941 | |
| 3942 | |
| 35 | 3943 /** |
| 3944 * The offset might be zero, in which case we have no data, so return a pair of null pointers. | |
| 3945 * Or, the offset might end in 0xf, so it is an id2 pointer, in which case we read the id2 block. | |
| 49 | 3946 * Otherwise, the high order 16 bits of offset is the index into the subblocks, and |
| 3947 * the (low order 16 bits of offset)>>4 is an index into the table of offsets in the subblock. | |
| 35 | 3948 */ |
| 49 | 3949 int pst_getBlockOffsetPointer(pst_file *pf, pst_index2_ll *i2_head, pst_subblocks *subblocks, uint32_t offset, pst_block_offset_pointer *p) { |
| 46 | 3950 size_t size; |
| 43 | 3951 pst_block_offset block_offset; |
| 46 | 3952 DEBUG_ENT("pst_getBlockOffsetPointer"); |
| 43 | 3953 if (p->needfree) free(p->from); |
| 49 | 3954 p->from = NULL; |
| 3955 p->to = NULL; | |
| 43 | 3956 p->needfree = 0; |
| 3957 if (!offset) { | |
| 49 | 3958 // no data |
| 43 | 3959 p->from = p->to = NULL; |
| 3960 } | |
| 46 | 3961 else if ((offset & 0xf) == (uint32_t)0xf) { |
| 49 | 3962 // external index reference |
| 43 | 3963 DEBUG_WARN(("Found id2 %#x value. Will follow it\n", offset)); |
| 46 | 3964 size = pst_ff_getID2block(pf, offset, i2_head, &(p->from)); |
| 43 | 3965 if (size) { |
| 3966 p->to = p->from + size; | |
| 3967 p->needfree = 1; | |
| 3968 } | |
| 3969 else { | |
| 50 | 3970 if (p->from) { |
| 3971 DEBUG_WARN(("size zero but non-null pointer\n")); | |
| 3972 free(p->from); | |
| 3973 } | |
| 43 | 3974 p->from = p->to = NULL; |
| 3975 } | |
| 3976 } | |
| 3977 else { | |
| 49 | 3978 // internal index reference |
| 3979 size_t subindex = offset >> 16; | |
| 3980 size_t suboffset = offset & 0xffff; | |
| 3981 if (subindex < subblocks->subblock_count) { | |
| 3982 if (pst_getBlockOffset(subblocks->subs[subindex].buf, | |
| 3983 subblocks->subs[subindex].read_size, | |
| 3984 subblocks->subs[subindex].i_offset, | |
| 3985 suboffset, &block_offset)) { | |
| 3986 p->from = subblocks->subs[subindex].buf + block_offset.from; | |
| 3987 p->to = subblocks->subs[subindex].buf + block_offset.to; | |
| 3988 } | |
| 3989 } | |
| 43 | 3990 } |
| 3991 DEBUG_RET(); | |
| 3992 return (p->from) ? 0 : 1; | |
| 35 | 3993 } |
| 3994 | |
| 3995 | |
| 52 | 3996 int pst_getBlockOffset(char *buf, size_t read_size, uint32_t i_offset, uint32_t offset, pst_block_offset *p) { |
| 46 | 3997 uint32_t low = offset & 0xf; |
| 3998 uint32_t of1 = offset >> 4; | |
| 3999 DEBUG_ENT("pst_getBlockOffset"); | |
| 43 | 4000 if (!p || !buf || !i_offset || low || (i_offset+2+of1+sizeof(*p) > read_size)) { |
| 4001 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)); | |
| 4002 DEBUG_RET(); | |
| 49 | 4003 return 0; |
| 43 | 4004 } |
| 4005 memcpy(&(p->from), &(buf[(i_offset+2)+of1]), sizeof(p->from)); | |
| 4006 memcpy(&(p->to), &(buf[(i_offset+2)+of1+sizeof(p->from)]), sizeof(p->to)); | |
| 4007 LE16_CPU(p->from); | |
| 4008 LE16_CPU(p->to); | |
| 4009 DEBUG_WARN(("get block offset finds from=%i(%#x), to=%i(%#x)\n", p->from, p->from, p->to, p->to)); | |
| 4010 if (p->from > p->to) { | |
| 4011 DEBUG_WARN(("get block offset from > to")); | |
| 52 | 4012 DEBUG_RET(); |
| 49 | 4013 return 0; |
| 43 | 4014 } |
| 4015 DEBUG_RET(); | |
| 49 | 4016 return 1; |
| 16 | 4017 } |
| 4018 | |
| 4019 | |
| 46 | 4020 pst_index_ll* pst_getID(pst_file* pf, uint64_t id) { |
| 43 | 4021 pst_index_ll *ptr = NULL; |
| 46 | 4022 DEBUG_ENT("pst_getID"); |
| 43 | 4023 if (id == 0) { |
| 4024 DEBUG_RET(); | |
| 4025 return NULL; | |
| 4026 } | |
| 4027 | |
| 46 | 4028 //if (id & 1) DEBUG_INDEX(("have odd id bit %#llx\n", id)); |
| 4029 //if (id & 2) DEBUG_INDEX(("have two id bit %#llx\n", id)); | |
| 43 | 4030 id -= (id & 1); |
| 4031 | |
| 4032 DEBUG_INDEX(("Trying to find %#llx\n", id)); | |
| 4033 if (!ptr) ptr = pf->i_head; | |
| 4034 while (ptr && (ptr->id != id)) { | |
| 4035 ptr = ptr->next; | |
| 4036 } | |
| 46 | 4037 if (ptr) {DEBUG_INDEX(("Found Value %#llx\n", id)); } |
| 4038 else {DEBUG_INDEX(("ERROR: Value %#llx not found\n", id)); } | |
| 43 | 4039 DEBUG_RET(); |
| 4040 return ptr; | |
| 16 | 4041 } |
| 4042 | |
| 4043 | |
| 46 | 4044 pst_index_ll * pst_getID2(pst_index2_ll *ptr, uint64_t id) { |
| 4045 DEBUG_ENT("pst_getID2"); | |
| 52 | 4046 DEBUG_INDEX(("Head = %p id = %#llx\n", ptr, id)); |
| 43 | 4047 while (ptr && (ptr->id2 != id)) { |
| 4048 ptr = ptr->next; | |
| 4049 } | |
| 4050 if (ptr) { | |
| 46 | 4051 if (ptr->id) {DEBUG_INDEX(("Found value %#llx\n", ptr->id->id)); } |
| 43 | 4052 else {DEBUG_INDEX(("Found value, though it is NULL!\n"));} |
| 4053 DEBUG_RET(); | |
| 4054 return ptr->id; | |
| 4055 } | |
| 4056 DEBUG_INDEX(("ERROR Not Found\n")); | |
| 4057 DEBUG_RET(); | |
| 4058 return NULL; | |
| 16 | 4059 } |
| 4060 | |
| 4061 | |
| 35 | 4062 /** |
| 4063 * find the id in the descriptor tree rooted at pf->d_head | |
| 4064 * | |
| 43 | 4065 * @param pf global pst file pointer |
| 4066 * @param id the id we are looking for | |
| 35 | 4067 * |
| 4068 * @return pointer to the pst_desc_ll node in the descriptor tree | |
| 4069 */ | |
| 46 | 4070 pst_desc_ll* pst_getDptr(pst_file *pf, uint64_t id) { |
| 43 | 4071 pst_desc_ll *ptr = pf->d_head; |
| 46 | 4072 DEBUG_ENT("pst_getDptr"); |
| 43 | 4073 while (ptr && (ptr->id != id)) { |
| 4074 if (ptr->child) { | |
| 4075 ptr = ptr->child; | |
| 4076 continue; | |
| 4077 } | |
| 4078 while (!ptr->next && ptr->parent) { | |
| 4079 ptr = ptr->parent; | |
| 4080 } | |
| 4081 ptr = ptr->next; | |
| 4082 } | |
| 4083 DEBUG_RET(); | |
| 4084 return ptr; // will be NULL or record we are looking for | |
| 16 | 4085 } |
| 4086 | |
| 4087 | |
| 51 | 4088 void pst_printDptr(pst_file *pf, pst_desc_ll *ptr) { |
| 46 | 4089 DEBUG_ENT("pst_printDptr"); |
| 43 | 4090 while (ptr) { |
| 51 | 4091 DEBUG_INDEX(("%#x [%i] desc=%#x, list=%#x\n", ptr->id, ptr->no_child, |
| 4092 (ptr->desc==NULL?0:ptr->desc->id), | |
| 4093 (ptr->list_index==NULL?0:ptr->list_index->id))); | |
| 43 | 4094 if (ptr->child) { |
| 51 | 4095 pst_printDptr(pf, ptr->child); |
| 43 | 4096 } |
| 4097 ptr = ptr->next; | |
| 4098 } | |
| 4099 DEBUG_RET(); | |
| 16 | 4100 } |
| 4101 | |
| 4102 | |
| 51 | 4103 void pst_printIDptr(pst_file* pf) { |
| 43 | 4104 pst_index_ll *ptr = pf->i_head; |
| 46 | 4105 DEBUG_ENT("pst_printIDptr"); |
| 43 | 4106 while (ptr) { |
| 4107 DEBUG_INDEX(("%#x offset=%#x size=%#x\n", ptr->id, ptr->offset, ptr->size)); | |
| 4108 ptr = ptr->next; | |
| 4109 } | |
| 4110 DEBUG_RET(); | |
| 16 | 4111 } |
| 4112 | |
| 4113 | |
| 51 | 4114 void pst_printID2ptr(pst_index2_ll *ptr) { |
| 46 | 4115 DEBUG_ENT("pst_printID2ptr"); |
| 43 | 4116 while (ptr) { |
| 4117 DEBUG_INDEX(("%#x id=%#x\n", ptr->id2, (ptr->id!=NULL?ptr->id->id:0))); | |
| 4118 ptr = ptr->next; | |
| 4119 } | |
| 4120 DEBUG_RET(); | |
| 16 | 4121 } |
| 4122 | |
| 4123 | |
| 52 | 4124 /** |
| 4125 * Read a block of data from file into memory | |
| 4126 * @param pf PST file | |
| 4127 * @param offset offset in the pst file of the data | |
| 4128 * @param size size of the block to be read | |
| 4129 * @param buf reference to pointer to buffer. If this pointer | |
| 4130 is non-NULL, it will first be free()d | |
| 4131 * @return size of block read into memory | |
| 4132 */ | |
| 51 | 4133 size_t pst_read_block_size(pst_file *pf, off_t offset, size_t size, char **buf) { |
| 4134 size_t rsize; | |
| 46 | 4135 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
|
4136 DEBUG_READ(("Reading block from %#llx, %x bytes\n", offset, size)); |
| 43 | 4137 |
| 4138 if (*buf) { | |
| 4139 DEBUG_READ(("Freeing old memory\n")); | |
| 4140 free(*buf); | |
| 4141 } | |
| 52 | 4142 *buf = (char*) xmalloc(size); |
| 4143 | |
| 4144 rsize = pst_getAtPos(pf, offset, *buf, size); | |
| 43 | 4145 if (rsize != size) { |
| 52 | 4146 DEBUG_WARN(("Didn't read all the data. fread returned less [%i instead of %i]\n", rsize, size)); |
| 43 | 4147 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
|
4148 DEBUG_WARN(("We tried to read past the end of the file at [offset %#llx, size %#x]\n", offset, size)); |
| 43 | 4149 } else if (ferror(pf->fp)) { |
| 4150 DEBUG_WARN(("Error is set on file stream.\n")); | |
| 4151 } else { | |
| 4152 DEBUG_WARN(("I can't tell why it failed\n")); | |
| 4153 } | |
| 4154 } | |
| 4155 | |
| 4156 DEBUG_RET(); | |
| 52 | 4157 return rsize; |
| 16 | 4158 } |
| 4159 | |
| 4160 | |
| 46 | 4161 int pst_decrypt(unsigned char *buf, size_t size, unsigned char type) { |
| 43 | 4162 size_t x = 0; |
| 4163 unsigned char y; | |
| 46 | 4164 DEBUG_ENT("pst_decrypt"); |
| 43 | 4165 if (!buf) { |
| 4166 DEBUG_RET(); | |
| 4167 return -1; | |
| 4168 } | |
| 4169 | |
| 4170 if (type == PST_COMP_ENCRYPT) { | |
| 4171 x = 0; | |
| 4172 while (x < size) { | |
| 4173 y = buf[x]; | |
| 4174 DEBUG_DECRYPT(("Transposing %#hhx to %#hhx [%#x]\n", buf[x], comp_enc[y], y)); | |
| 4175 buf[x] = comp_enc[y]; // transpose from encrypt array | |
| 4176 x++; | |
| 4177 } | |
| 4178 } else { | |
| 4179 WARN(("Unknown encryption: %i. Cannot decrypt\n", type)); | |
| 4180 DEBUG_RET(); | |
| 4181 return -1; | |
| 4182 } | |
| 4183 DEBUG_RET(); | |
| 4184 return 0; | |
| 16 | 4185 } |
| 4186 | |
| 4187 | |
| 46 | 4188 uint64_t pst_getIntAt(pst_file *pf, char *buf) { |
| 4189 uint64_t buf64; | |
| 4190 uint32_t buf32; | |
| 4191 if (pf->do_read64) { | |
| 43 | 4192 memcpy(&buf64, buf, sizeof(buf64)); |
| 4193 LE64_CPU(buf64); | |
| 4194 return buf64; | |
| 4195 } | |
| 4196 else { | |
| 4197 memcpy(&buf32, buf, sizeof(buf32)); | |
| 4198 LE32_CPU(buf32); | |
| 4199 return buf32; | |
| 4200 } | |
| 4201 } | |
| 4202 | |
| 4203 | |
| 46 | 4204 uint64_t pst_getIntAtPos(pst_file *pf, off_t pos ) { |
| 4205 uint64_t buf64; | |
| 4206 uint32_t buf32; | |
| 4207 if (pf->do_read64) { | |
| 52 | 4208 (void)pst_getAtPos(pf, pos, &buf64, sizeof(buf64)); |
| 43 | 4209 LE64_CPU(buf64); |
| 4210 return buf64; | |
| 4211 } | |
| 4212 else { | |
| 52 | 4213 (void)pst_getAtPos(pf, pos, &buf32, sizeof(buf32)); |
| 43 | 4214 LE32_CPU(buf32); |
| 4215 return buf32; | |
| 4216 } | |
| 16 | 4217 } |
| 4218 | |
| 52 | 4219 /** |
| 4220 * Read part of the pst file. | |
| 4221 * | |
| 4222 * @param pf PST file structure | |
| 4223 * @param pos offset of the data in the pst file | |
| 4224 * @param buf buffer to contain the data | |
| 4225 * @param size size of the buffer and the amount of data to be read | |
| 4226 * @return actual read size, 0 if seek error | |
| 4227 */ | |
| 4228 | |
| 4229 size_t pst_getAtPos(pst_file *pf, off_t pos, void* buf, size_t size) { | |
| 4230 size_t rc; | |
| 46 | 4231 DEBUG_ENT("pst_getAtPos"); |
| 52 | 4232 // pst_block_recorder **t = &pf->block_head; |
| 4233 // pst_block_recorder *p = pf->block_head; | |
| 4234 // while (p && ((p->offset+p->size) <= pos)) { | |
| 4235 // t = &p->next; | |
| 4236 // p = p->next; | |
| 4237 // } | |
| 4238 // if (p && (p->offset <= pos) && (pos < (p->offset+p->size))) { | |
| 4239 // // bump the count | |
| 4240 // p->readcount++; | |
| 4241 // } else { | |
| 4242 // // add a new block | |
| 4243 // pst_block_recorder *tail = *t; | |
| 4244 // p = (pst_block_recorder*)xmalloc(sizeof(*p)); | |
| 4245 // *t = p; | |
| 4246 // p->next = tail; | |
| 4247 // p->offset = pos; | |
| 4248 // p->size = size; | |
| 4249 // p->readcount = 1; | |
| 4250 // } | |
| 4251 // DEBUG_MAIN(("pst file old offset %#llx old size %#x read count %i offset %#llx size %#x\n", | |
| 4252 // p->offset, p->size, p->readcount, pos, size)); | |
| 4253 | |
| 4254 if (fseek(pf->fp, pos, SEEK_SET) == -1) { | |
| 43 | 4255 DEBUG_RET(); |
| 52 | 4256 return 0; |
| 43 | 4257 } |
| 52 | 4258 rc = fread(buf, (size_t)1, size, pf->fp); |
| 43 | 4259 DEBUG_RET(); |
| 52 | 4260 return rc; |
| 16 | 4261 } |
| 4262 | |
| 4263 | |
| 50 | 4264 /** |
| 4265 * Get an ID block from file using _pst_ff_getIDblock and decrypt if necessary | |
| 52 | 4266 * |
| 4267 * @param pf PST file structure | |
| 4268 * @param id ID of block to retrieve | |
| 4269 * @param buf Reference to pointer that will be set to new block. Any memory | |
| 4270 pointed to by buffer will be free()d beforehand | |
| 4271 * @return Size of block pointed to by *b | |
| 50 | 4272 */ |
| 52 | 4273 size_t pst_ff_getIDblock_dec(pst_file *pf, uint64_t id, char **buf) { |
| 43 | 4274 size_t r; |
| 46 | 4275 int noenc = (int)(id & 2); // disable encryption |
| 4276 DEBUG_ENT("pst_ff_getIDblock_dec"); | |
| 43 | 4277 DEBUG_INDEX(("for id %#x\n", id)); |
| 52 | 4278 r = pst_ff_getIDblock(pf, id, buf); |
| 46 | 4279 if ((pf->encryption) && !(noenc)) { |
| 52 | 4280 (void)pst_decrypt(*buf, r, pf->encryption); |
| 43 | 4281 } |
| 52 | 4282 DEBUG_HEXDUMPC(*buf, r, 16); |
| 43 | 4283 DEBUG_RET(); |
| 4284 return r; | |
| 4285 } | |
| 4286 | |
| 4287 | |
| 50 | 4288 /** |
| 4289 * Read a block of data from file into memory | |
| 52 | 4290 * @param pf PST file |
| 4291 * @param id identifier of block to read | |
| 4292 * @param buf reference to pointer to buffer. If this pointer | |
| 4293 is non-NULL, it will first be free()d | |
| 4294 * @return size of block read into memory | |
| 50 | 4295 */ |
| 52 | 4296 size_t pst_ff_getIDblock(pst_file *pf, uint64_t id, char** buf) { |
| 43 | 4297 pst_index_ll *rec; |
| 52 | 4298 size_t rsize; |
| 46 | 4299 DEBUG_ENT("pst_ff_getIDblock"); |
| 52 | 4300 rec = pst_getID(pf, id); |
| 4301 if (!rec) { | |
| 48 | 4302 DEBUG_INDEX(("Cannot find ID %#llx\n", id)); |
| 43 | 4303 DEBUG_RET(); |
| 4304 return 0; | |
| 4305 } | |
| 48 | 4306 DEBUG_INDEX(("id = %#llx, record size = %#x, offset = %#x\n", id, rec->size, rec->offset)); |
| 52 | 4307 rsize = pst_read_block_size(pf, rec->offset, rec->size, buf); |
| 43 | 4308 DEBUG_RET(); |
| 4309 return rsize; | |
| 16 | 4310 } |
| 4311 | |
| 4312 | |
| 4313 #define PST_PTR_BLOCK_SIZE 0x120 | |
| 52 | 4314 size_t pst_ff_getID2block(pst_file *pf, uint64_t id2, pst_index2_ll *id2_head, char** buf) { |
| 50 | 4315 size_t ret; |
| 43 | 4316 pst_index_ll* ptr; |
| 49 | 4317 pst_holder h = {buf, NULL, 0, "", 0}; |
| 46 | 4318 DEBUG_ENT("pst_ff_getID2block"); |
| 4319 ptr = pst_getID2(id2_head, id2); | |
| 43 | 4320 |
| 4321 if (!ptr) { | |
| 4322 DEBUG_INDEX(("Cannot find id2 value %#x\n", id2)); | |
| 4323 DEBUG_RET(); | |
| 4324 return 0; | |
| 4325 } | |
| 50 | 4326 ret = pst_ff_getID2data(pf, ptr, &h); |
| 43 | 4327 DEBUG_RET(); |
| 50 | 4328 return ret; |
| 16 | 4329 } |
| 4330 | |
| 4331 | |
| 49 | 4332 size_t pst_ff_getID2data(pst_file *pf, pst_index_ll *ptr, pst_holder *h) { |
| 46 | 4333 size_t ret; |
| 52 | 4334 char *b = NULL, *t; |
| 46 | 4335 DEBUG_ENT("pst_ff_getID2data"); |
| 43 | 4336 if (!(ptr->id & 0x02)) { |
| 46 | 4337 ret = pst_ff_getIDblock_dec(pf, ptr->id, &b); |
| 43 | 4338 if (h->buf) { |
| 4339 *(h->buf) = b; | |
| 4340 } else if ((h->base64 == 1) && h->fp) { | |
| 4341 t = base64_encode(b, ret); | |
| 4342 if (t) { | |
| 47 | 4343 (void)pst_fwrite(t, (size_t)1, strlen(t), h->fp); |
| 43 | 4344 free(t); // caught by valgrind |
| 4345 } | |
| 4346 free(b); | |
| 4347 } else if (h->fp) { | |
| 47 | 4348 (void)pst_fwrite(b, (size_t)1, ret, h->fp); |
| 43 | 4349 free(b); |
| 46 | 4350 } else { |
| 4351 // h-> does not specify any output | |
| 43 | 4352 } |
| 46 | 4353 |
| 43 | 4354 } else { |
| 4355 // here we will assume it is a block that points to others | |
| 4356 DEBUG_READ(("Assuming it is a multi-block record because of it's id\n")); | |
| 46 | 4357 ret = pst_ff_compile_ID(pf, ptr->id, h, (size_t)0); |
| 43 | 4358 } |
| 52 | 4359 // bogus null termination off the end of the buffer!! |
| 4360 //if (h->buf && *h->buf) (*(h->buf))[ret]='\0'; | |
| 43 | 4361 DEBUG_RET(); |
| 4362 return ret; | |
| 16 | 4363 } |
| 4364 | |
| 4365 | |
| 49 | 4366 size_t pst_ff_compile_ID(pst_file *pf, uint64_t id, pst_holder *h, size_t size) { |
| 51 | 4367 size_t z, a, b; |
| 43 | 4368 uint16_t count, y; |
| 52 | 4369 char * buf3 = NULL, *buf2 = NULL, *t; |
| 4370 char *b_ptr; | |
| 50 | 4371 pst_block_hdr block_hdr; |
| 4372 pst_table3_rec table3_rec; //for type 3 (0x0101) blocks | |
| 43 | 4373 |
| 46 | 4374 DEBUG_ENT("pst_ff_compile_ID"); |
| 4375 a = pst_ff_getIDblock(pf, id, &buf3); | |
| 43 | 4376 if (!a) { |
| 4377 if (buf3) free(buf3); | |
| 52 | 4378 DEBUG_RET(); |
| 43 | 4379 return 0; |
| 4380 } | |
| 50 | 4381 DEBUG_HEXDUMPC(buf3, a, 0x10); |
| 4382 memcpy(&block_hdr, buf3, sizeof(block_hdr)); | |
| 4383 LE16_CPU(block_hdr.index_offset); | |
| 4384 LE16_CPU(block_hdr.type); | |
| 4385 LE32_CPU(block_hdr.offset); | |
| 4386 DEBUG_EMAIL(("block header (index_offset=%#hx, type=%#hx, offset=%#x)\n", block_hdr.index_offset, block_hdr.type, block_hdr.offset)); | |
| 4387 | |
| 4388 if (block_hdr.index_offset != (uint16_t)0x0101) { //type 3 | |
| 4389 DEBUG_WARN(("WARNING: not a type 0x0101 buffer, Treating as normal buffer\n")); | |
| 46 | 4390 if (pf->encryption) (void)pst_decrypt(buf3, a, pf->encryption); |
| 43 | 4391 if (h->buf) |
| 4392 *(h->buf) = buf3; | |
| 4393 else if (h->base64 == 1 && h->fp) { | |
| 4394 t = base64_encode(buf3, a); | |
| 4395 if (t) { | |
| 47 | 4396 (void)pst_fwrite(t, (size_t)1, strlen(t), h->fp); |
| 43 | 4397 free(t); // caught by valgrind |
| 4398 } | |
| 4399 free(buf3); | |
| 4400 } else if (h->fp) { | |
| 47 | 4401 (void)pst_fwrite(buf3, (size_t)1, a, h->fp); |
| 43 | 4402 free(buf3); |
| 46 | 4403 } else { |
| 4404 // h-> does not specify any output | |
| 43 | 4405 } |
| 4406 DEBUG_RET(); | |
| 4407 return a; | |
| 4408 } | |
| 50 | 4409 count = block_hdr.type; |
| 4410 b_ptr = buf3 + 8; | |
| 4411 for (y=0; y<count; y++) { | |
| 4412 b_ptr += pst_decode_type3(pf, &table3_rec, b_ptr); | |
| 4413 z = pst_ff_getIDblock_dec(pf, table3_rec.id, &buf2); | |
| 4414 if (!z) { | |
| 4415 DEBUG_WARN(("call to getIDblock returned zero %i\n", z)); | |
| 4416 if (buf2) free(buf2); | |
| 4417 free(buf3); | |
| 52 | 4418 DEBUG_RET(); |
| 50 | 4419 return z; |
| 4420 } | |
| 4421 if (h->buf) { | |
| 4422 *(h->buf) = realloc(*(h->buf), size+z+1); | |
| 4423 DEBUG_READ(("appending read data of size %i onto main buffer from pos %i\n", z, size)); | |
| 4424 memcpy(&((*(h->buf))[size]), buf2, z); | |
| 4425 } else if ((h->base64 == 1) && h->fp) { | |
| 4426 // include any byte left over from the last one encoding | |
| 4427 buf2 = (char*)realloc(buf2, z+h->base64_extra); | |
| 4428 memmove(buf2+h->base64_extra, buf2, z); | |
| 4429 memcpy(buf2, h->base64_extra_chars, h->base64_extra); | |
| 4430 z += h->base64_extra; | |
| 4431 | |
| 4432 b = z % 3; // find out how many bytes will be left over after the encoding. | |
| 4433 // and save them | |
| 4434 memcpy(h->base64_extra_chars, &(buf2[z-b]), b); | |
| 4435 h->base64_extra = b; | |
| 4436 t = base64_encode(buf2, z-b); | |
| 4437 if (t) { | |
| 4438 DEBUG_READ(("writing %i bytes to file as base64 [%i]. Currently %i\n", z, strlen(t), size)); | |
| 4439 (void)pst_fwrite(t, (size_t)1, strlen(t), h->fp); | |
| 4440 free(t); // caught by valgrind | |
| 43 | 4441 } |
| 50 | 4442 } else if (h->fp) { |
| 4443 DEBUG_READ(("writing %i bytes to file. Currently %i\n", z, size)); | |
| 4444 (void)pst_fwrite(buf2, (size_t)1, z, h->fp); | |
| 4445 } else { | |
| 4446 // h-> does not specify any output | |
| 43 | 4447 } |
| 50 | 4448 size += z; |
| 43 | 4449 } |
| 4450 free(buf3); | |
| 4451 if (buf2) free(buf2); | |
| 4452 DEBUG_RET(); | |
| 4453 return size; | |
| 16 | 4454 } |
| 4455 | |
| 4456 | |
| 4457 #ifdef _MSC_VER | |
| 4458 char * fileTimeToAscii(const FILETIME* filetime) { | |
| 43 | 4459 time_t t; |
| 4460 DEBUG_ENT("fileTimeToAscii"); | |
| 4461 t = fileTimeToUnixTime(filetime, 0); | |
| 4462 if (t == -1) | |
| 4463 DEBUG_WARN(("ERROR time_t varible that was produced, is -1\n")); | |
| 4464 DEBUG_RET(); | |
| 4465 return ctime(&t); | |
| 16 | 4466 } |
| 4467 | |
| 4468 | |
| 4469 time_t fileTimeToUnixTime(const FILETIME* filetime, DWORD *x) { | |
| 43 | 4470 SYSTEMTIME s; |
| 4471 struct tm t; | |
| 4472 DEBUG_ENT("fileTimeToUnixTime"); | |
| 4473 memset (&t, 0, sizeof(struct tm)); | |
| 4474 FileTimeToSystemTime(filetime, &s); | |
| 4475 t.tm_year = s.wYear-1900; // this is what is required | |
| 4476 t.tm_mon = s.wMonth-1; // also required! It made me a bit confused | |
| 4477 t.tm_mday = s.wDay; | |
| 4478 t.tm_hour = s.wHour; | |
| 4479 t.tm_min = s.wMinute; | |
| 4480 t.tm_sec = s.wSecond; | |
| 4481 DEBUG_RET(); | |
| 4482 return mktime(&t); | |
| 16 | 4483 } |
| 4484 | |
| 4485 | |
| 4486 struct tm * fileTimeToStructTM (const FILETIME *filetime) { | |
| 43 | 4487 time_t t1; |
| 4488 t1 = fileTimeToUnixTime(filetime, 0); | |
| 4489 return gmtime(&t1); | |
| 16 | 4490 } |
| 4491 | |
| 4492 | |
| 4493 #endif //_MSC_VER | |
| 4494 | |
| 46 | 4495 int pst_stricmp(char *a, char *b) { |
| 43 | 4496 // compare strings case-insensitive. |
| 4497 // returns -1 if a < b, 0 if a==b, 1 if a > b | |
| 4498 while(*a != '\0' && *b != '\0' && toupper(*a)==toupper(*b)) { | |
| 4499 a++; b++; | |
| 4500 } | |
| 4501 if (toupper(*a) == toupper(*b)) | |
| 4502 return 0; | |
| 4503 else if (toupper(*a) < toupper(*b)) | |
| 4504 return -1; | |
| 4505 else | |
| 4506 return 1; | |
| 16 | 4507 } |
| 4508 | |
| 4509 | |
| 46 | 4510 int pst_strincmp(char *a, char *b, size_t x) { |
| 43 | 4511 // compare upto x chars in string a and b case-insensitively |
| 4512 // returns -1 if a < b, 0 if a==b, 1 if a > b | |
| 46 | 4513 size_t y = 0; |
| 43 | 4514 while (*a != '\0' && *b != '\0' && y < x && toupper(*a)==toupper(*b)) { |
| 4515 a++; b++; y++; | |
| 4516 } | |
| 4517 // if we have reached the end of either string, or a and b still match | |
| 4518 if (*a == '\0' || *b == '\0' || toupper(*a)==toupper(*b)) | |
| 4519 return 0; | |
| 4520 else if (toupper(*a) < toupper(*b)) | |
| 4521 return -1; | |
| 4522 else | |
| 4523 return 1; | |
| 16 | 4524 } |
| 4525 | |
| 4526 | |
| 4527 size_t pst_fwrite(const void*ptr, size_t size, size_t nmemb, FILE*stream) { | |
| 43 | 4528 size_t r; |
| 4529 DEBUG_ENT("pst_fwrite"); | |
| 4530 if (ptr) | |
| 4531 r = fwrite(ptr, size, nmemb, stream); | |
| 4532 else { | |
| 4533 r = 0; | |
| 4534 DEBUG_WARN(("An attempt to write a NULL Pointer was made\n")); | |
| 4535 } | |
| 4536 DEBUG_RET(); | |
| 4537 return r; | |
| 16 | 4538 } |
| 4539 | |
| 4540 | |
| 47 | 4541 char * pst_wide_to_single(char *wt, size_t size) { |
| 43 | 4542 // returns the first byte of each wide char. the size is the number of bytes in source |
| 4543 char *x, *y; | |
| 46 | 4544 DEBUG_ENT("pst_wide_to_single"); |
| 43 | 4545 x = xmalloc((size/2)+1); |
| 4546 y = x; | |
| 4547 while (size != 0 && *wt != '\0') { | |
| 4548 *y = *wt; | |
| 4549 wt+=2; | |
| 4550 size -= 2; | |
| 4551 y++; | |
| 4552 } | |
| 4553 *y = '\0'; | |
| 4554 DEBUG_RET(); | |
| 4555 return x; | |
| 16 | 4556 } |
| 4557 | |
| 43 | 4558 |
| 4559 char *pst_rfc2426_escape(char *str) { | |
| 48 | 4560 static char* buf = NULL; |
| 4561 static size_t buflen = 0; | |
| 43 | 4562 char *ret, *a, *b; |
| 47 | 4563 size_t x = 0; |
| 4564 int y, z; | |
| 43 | 4565 DEBUG_ENT("rfc2426_escape"); |
| 4566 if (!str) | |
| 4567 ret = str; | |
| 4568 else { | |
| 4569 | |
| 4570 // calculate space required to escape all the following characters | |
| 4571 y = pst_chr_count(str, ',') | |
| 4572 + pst_chr_count(str, '\\') | |
| 4573 + pst_chr_count(str, ';') | |
| 4574 + pst_chr_count(str, '\n'); | |
| 4575 z = pst_chr_count(str, '\r'); | |
| 4576 if (y == 0 && z == 0) | |
| 4577 // there isn't any extra space required | |
| 4578 ret = str; | |
| 4579 else { | |
| 4580 x = strlen(str) + y - z + 1; // don't forget room for the NUL | |
| 48 | 4581 if (x > buflen) { |
| 4582 buf = (char*) realloc(buf, x); | |
| 4583 buflen = x; | |
| 4584 } | |
| 43 | 4585 a = str; |
| 4586 b = buf; | |
| 4587 while (*a != '\0') { | |
| 4588 switch (*a) { | |
| 4589 case ',' : | |
| 4590 case '\\': | |
| 4591 case ';' : | |
| 4592 *(b++) = '\\'; | |
| 4593 *b = *a; | |
| 4594 break; | |
| 4595 case '\n': // newlines are encoded as "\n" | |
| 4596 *(b++) = '\\'; | |
| 4597 *b = 'n'; | |
| 4598 break; | |
| 4599 case '\r': // skip cr | |
| 4600 b--; | |
| 4601 break; | |
| 4602 default: | |
| 4603 *b=*a; | |
| 4604 } | |
| 4605 b++; | |
| 4606 a++; | |
| 4607 } | |
| 4608 *b = '\0'; // NUL-terminate the string (buf) | |
| 4609 ret = buf; | |
| 4610 } | |
| 4611 } | |
| 4612 DEBUG_RET(); | |
| 4613 return ret; | |
| 4614 } | |
| 4615 | |
| 4616 | |
| 4617 int pst_chr_count(char *str, char x) { | |
| 4618 int r = 0; | |
| 46 | 4619 while (*str) { |
| 4620 if (*str == x) r++; | |
| 43 | 4621 str++; |
| 4622 } | |
| 4623 return r; | |
| 4624 } | |
| 4625 | |
| 4626 | |
| 4627 char *pst_rfc2425_datetime_format(FILETIME *ft) { | |
| 47 | 4628 static char buffer[30]; |
| 43 | 4629 struct tm *stm = NULL; |
| 4630 DEBUG_ENT("rfc2425_datetime_format"); | |
| 4631 stm = fileTimeToStructTM(ft); | |
| 47 | 4632 if (strftime(buffer, sizeof(buffer), "%Y-%m-%dT%H:%M:%SZ", stm)==0) { |
| 43 | 4633 DEBUG_INFO(("Problem occured formatting date\n")); |
| 4634 } | |
| 4635 DEBUG_RET(); | |
| 4636 return buffer; | |
| 4637 } | |
| 4638 | |
| 4639 | |
| 4640 char *pst_rfc2445_datetime_format(FILETIME *ft) { | |
| 47 | 4641 static char buffer[30]; |
| 43 | 4642 struct tm *stm = NULL; |
| 4643 DEBUG_ENT("rfc2445_datetime_format"); | |
| 4644 stm = fileTimeToStructTM(ft); | |
| 47 | 4645 if (strftime(buffer, sizeof(buffer), "%Y%m%dT%H%M%SZ", stm)==0) { |
| 43 | 4646 DEBUG_INFO(("Problem occured formatting date\n")); |
| 4647 } | |
| 4648 DEBUG_RET(); | |
| 4649 return buffer; | |
| 4650 } | |
| 4651 | |
| 4652 |