libpst: src/libpst.c comparison

comparison src/libpst.c @ 176:ac6e22c8a9cf

build separate libpst, libpst-libs, libpst-devel rpms. remove many functions from the interface by making them static.

author	Carl Byington <carl@five-ten-sg.com>
date	Wed, 08 Apr 2009 14:13:06 -0700
parents	6954d315aaa8
children	b65e8d0a088a

comparison

equal deleted inserted replaced

-:03dbd449290f
+:ac6e22c8a9cf
 0x27, 0x3b, 0xda, 0xba, 0xd7, 0xc2, 0x26, 0xd4, 0x91, 0x1d, 0xd2, 0x1c, 0x22, 0x33, 0xf8, 0xfa,
 0xf1, 0x5a, 0xef, 0xcf, 0x90, 0xb6, 0x8b, 0xb5, 0xbd, 0xc0, 0xbf, 0x08, 0x97, 0x1e, 0x6c, 0xe2,
 0x61, 0xe0, 0xc6, 0xc1, 0x59, 0xab, 0xbb, 0x58, 0xde, 0x5f, 0xdf, 0x60, 0x79, 0x7e, 0xb2, 0x8a
 };
+static int              pst_build_desc_ptr(pst_file *pf, int64_t offset, int32_t depth, uint64_t linku1, uint64_t start_val, uint64_t end_val);
+static pst_id2_ll*      pst_build_id2(pst_file *pf, pst_index_ll* list);
+static int              pst_build_id_ptr(pst_file *pf, int64_t offset, int32_t depth, uint64_t linku1, uint64_t start_val, uint64_t end_val);
+static int              pst_chr_count(char *str, char x);
+static size_t           pst_ff_compile_ID(pst_file *pf, uint64_t id, pst_holder *h, size_t size);
+static size_t           pst_ff_getID2block(pst_file *pf, uint64_t id2, pst_id2_ll *id2_head, char** buf);
+static size_t           pst_ff_getID2data(pst_file *pf, pst_index_ll *ptr, pst_holder *h);
+static void             pst_free_attach(pst_item_attach *attach);
+static void             pst_free_desc (pst_desc_ll *head);
+static void             pst_free_id2(pst_id2_ll * head);
+static void             pst_free_id (pst_index_ll *head);
+static void             pst_free_list(pst_mapi_object *list);
+static void             pst_free_xattrib(pst_x_attrib_ll *x);
+static size_t           pst_getAtPos(pst_file *pf, int64_t pos, void* buf, size_t size);
+static int              pst_getBlockOffsetPointer(pst_file *pf, pst_id2_ll *i2_head, pst_subblocks *subblocks, uint32_t offset, pst_block_offset_pointer *p);
+static int              pst_getBlockOffset(char *buf, size_t read_size, uint32_t i_offset, uint32_t offset, pst_block_offset *p);
+static pst_id2_ll*      pst_getID2(pst_id2_ll * ptr, uint64_t id);
+static pst_desc_ll*     pst_getDptr(pst_file *pf, uint64_t d_id);
+static uint64_t         pst_getIntAt(pst_file *pf, char *buf);
+static uint64_t         pst_getIntAtPos(pst_file *pf, int64_t pos);
+static pst_mapi_object* pst_parse_block(pst_file *pf, uint64_t block_id, pst_id2_ll *i2_head);
+static void             pst_printDptr(pst_file *pf, pst_desc_ll *ptr);
+static void             pst_printIDptr(pst_file* pf);
+static void             pst_printID2ptr(pst_id2_ll *ptr);
+static int              pst_process(pst_mapi_object *list, pst_item *item, pst_item_attach *attach);
+static size_t           pst_read_block_size(pst_file *pf, int64_t offset, size_t size, char **buf);
+static int              pst_stricmp(char *a, char *b);
+static int              pst_strincmp(char *a, char *b, size_t x);
+static char*            pst_wide_to_single(char *wt, size_t size);
 int pst_open(pst_file *pf, char *name) {
 int32_t sig;
 pst_unicode_init();
 topnode->desc        = NULL;
 record_descriptor(pf, topnode);   // add to the global tree
 }
 DEBUG_RET();
 return topnode;
-}
-size_t pst_attach_to_mem(pst_file *pf, pst_item_attach *attach, char **b){
-size_t size=0;
-pst_index_ll *ptr;
-pst_holder h = {b, NULL, 0};
-DEBUG_ENT("pst_attach_to_mem");
-if (attach->i_id != (uint64_t)-1) {
-ptr = pst_getID(pf, attach->i_id);
-if (ptr) {
-size = pst_ff_getID2data(pf, ptr, &h);
-} else {
-DEBUG_WARN(("Couldn't find ID pointer. Cannot handle attachment\n"));
-size = 0;
-}
-attach->data.size = size;
-} else {
-size = attach->data.size;
-}
-DEBUG_RET();
-return size;
 }
 size_t pst_attach_to_file(pst_file *pf, pst_item_attach *attach, FILE* fp) {
 pst_index_ll *ptr;
 /** Process the index1 b-tree from the pst file and create the
 *  pf->i_head linked list from it. This tree holds the location
 *  (offset and size) of lower level objects (0xbcec descriptor
 *  blocks, etc) in the pst file.
 */
-int pst_build_id_ptr(pst_file *pf, int64_t offset, int32_t depth, uint64_t linku1, uint64_t start_val, uint64_t end_val) {
+static int pst_build_id_ptr(pst_file *pf, int64_t offset, int32_t depth, uint64_t linku1, uint64_t start_val, uint64_t end_val) {
 struct pst_table_ptr_structn table, table2;
 pst_index_ll *i_ptr=NULL;
 pst_index index;
 int32_t x, item_count;
 uint64_t old = start_val;
 /** Process the index2 b-tree from the pst file and create the
 *  pf->d_head tree from it. This tree holds descriptions of the
 *  higher level objects (email, contact, etc) in the pst file.
 */
-int pst_build_desc_ptr (pst_file *pf, int64_t offset, int32_t depth, uint64_t linku1, uint64_t start_val, uint64_t end_val) {
+static int pst_build_desc_ptr (pst_file *pf, int64_t offset, int32_t depth, uint64_t linku1, uint64_t start_val, uint64_t end_val) {
 struct pst_table_ptr_structn table, table2;
 pst_descn desc_rec;
 int32_t item_count;
 uint64_t old = start_val;
 int x;
 /** Process a low level descriptor block (0x0101, 0xbcec, 0x7cec) into a
 *  list of MAPI objects, each of which contains a list of MAPI elements.
 *
 *  @return list of MAPI objects
 */
-pst_mapi_object * pst_parse_block(pst_file *pf, uint64_t block_id, pst_id2_ll *i2_head) {
+static pst_mapi_object* pst_parse_block(pst_file *pf, uint64_t block_id, pst_id2_ll *i2_head) {
 pst_mapi_object *mo_head = NULL;
 char  *buf       = NULL;
 size_t read_size = 0;
 pst_subblocks  subblocks;
 pst_mapi_object *mo_ptr = NULL;
 *               this is non-null, the length of the this attachment list
 *               must be at least as large as the length of the MAPI objects list.
 *
 * @return 0 for ok, -1 for error.
 */
-int pst_process(pst_mapi_object *list, pst_item *item, pst_item_attach *attach) {
+static int pst_process(pst_mapi_object *list, pst_item *item, pst_item_attach *attach) {
 DEBUG_ENT("pst_process");
 if (!item) {
 DEBUG_EMAIL(("item cannot be NULL.\n"));
 DEBUG_RET();
 return -1;
 DEBUG_RET();
 return 0;
 }
-void pst_free_list(pst_mapi_object *list) {
+static void pst_free_list(pst_mapi_object *list) {
 pst_mapi_object *l;
 DEBUG_ENT("pst_free_list");
 while (list) {
 if (list->elements) {
 int32_t x;
 }
 DEBUG_RET();
 }
-void pst_free_id2(pst_id2_ll * head) {
+static void pst_free_id2(pst_id2_ll * head) {
 pst_id2_ll *t;
 DEBUG_ENT("pst_free_id2");
 while (head) {
 if (head->child) pst_free_id2(head->child);
 t = head->next;
 }
 DEBUG_RET();
 }
-void pst_free_id (pst_index_ll *head) {
+static void pst_free_id (pst_index_ll *head) {
 pst_index_ll *t;
 DEBUG_ENT("pst_free_id");
 while (head) {
 t = head->next;
 free(head);
 }
 DEBUG_RET();
 }
-void pst_free_desc (pst_desc_ll *head) {
+static void pst_free_desc (pst_desc_ll *head) {
 pst_desc_ll *t;
 DEBUG_ENT("pst_free_desc");
 while (head) {
 while (head->child) {
 head = head->child;
 }
 DEBUG_RET();
 }
-void pst_free_xattrib(pst_x_attrib_ll *x) {
+static void pst_free_xattrib(pst_x_attrib_ll *x) {
 pst_x_attrib_ll *t;
 DEBUG_ENT("pst_free_xattrib");
 while (x) {
 if (x->data) free(x->data);
 t = x->next;
 }
 DEBUG_RET();
 }
-pst_id2_ll * pst_build_id2(pst_file *pf, pst_index_ll* list) {
+static pst_id2_ll * pst_build_id2(pst_file *pf, pst_index_ll* list) {
 pst_block_header block_head;
 pst_id2_ll *head = NULL, *tail = NULL;
 uint16_t x = 0;
 char *b_ptr = NULL;
 char *buf = NULL;
 DEBUG_RET();
 return head;
 }
-void pst_free_attach(pst_item_attach *attach) {
+static void pst_free_attach(pst_item_attach *attach) {
 while (attach) {
 pst_item_attach *t;
 SAFE_FREE_STR(attach->filename1);
 SAFE_FREE_STR(attach->filename2);
 SAFE_FREE_STR(attach->mimetype);
 * The offset might be zero, in which case we have no data, so return a pair of null pointers.
 * Or, the offset might end in 0xf, so it is an id2 pointer, in which case we read the id2 block.
 * Otherwise, the high order 16 bits of offset is the index into the subblocks, and
 * the (low order 16 bits of offset)>>4 is an index into the table of offsets in the subblock.
 */
-int pst_getBlockOffsetPointer(pst_file *pf, pst_id2_ll *i2_head, pst_subblocks *subblocks, uint32_t offset, pst_block_offset_pointer *p) {
+static int pst_getBlockOffsetPointer(pst_file *pf, pst_id2_ll *i2_head, pst_subblocks *subblocks, uint32_t offset, pst_block_offset_pointer *p) {
 size_t size;
 pst_block_offset block_offset;
 DEBUG_ENT("pst_getBlockOffsetPointer");
 if (p->needfree) free(p->from);
 p->from     = NULL;
 DEBUG_RET();
 return (p->from) ? 0 : 1;
 }
-int pst_getBlockOffset(char *buf, size_t read_size, uint32_t i_offset, uint32_t offset, pst_block_offset *p) {
+static int pst_getBlockOffset(char *buf, size_t read_size, uint32_t i_offset, uint32_t offset, pst_block_offset *p) {
 uint32_t low = offset & 0xf;
 uint32_t of1 = offset >> 4;
 DEBUG_ENT("pst_getBlockOffset");
 if (!p || !buf || !i_offset || low || (i_offset+2+of1+sizeof(*p) > read_size)) {
 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));
 DEBUG_RET();
 return ptr;
 }
-pst_id2_ll *pst_getID2(pst_id2_ll *head, uint64_t id2) {
+static pst_id2_ll *pst_getID2(pst_id2_ll *head, uint64_t id2) {
 DEBUG_ENT("pst_getID2");
 DEBUG_INDEX(("looking for id2 = %#"PRIx64"\n", id2));
 pst_id2_ll *ptr = head;
 while (ptr) {
 if (ptr->id2 == id2) break;
 * @param pf    global pst file pointer
 * @param d_id  the id we are looking for
 *
 * @return pointer to the pst_desc_ll node in the descriptor tree
 */
-pst_desc_ll* pst_getDptr(pst_file *pf, uint64_t d_id) {
+static pst_desc_ll* pst_getDptr(pst_file *pf, uint64_t d_id) {
 pst_desc_ll *ptr = pf->d_head;
 DEBUG_ENT("pst_getDptr");
 while (ptr && (ptr->d_id != d_id)) {
 //DEBUG_INDEX(("Looking for %#"PRIx64" at node %#"PRIx64" with parent %#"PRIx64"\n", id, ptr->d_id, ptr->parent_d_id));
 if (ptr->child) {
 DEBUG_RET();
 return ptr; // will be NULL or record we are looking for
 }
-void pst_printDptr(pst_file *pf, pst_desc_ll *ptr) {
+static void pst_printDptr(pst_file *pf, pst_desc_ll *ptr) {
 DEBUG_ENT("pst_printDptr");
 while (ptr) {
 DEBUG_INDEX(("%#"PRIx64" [%i] desc=%#"PRIx64", assoc tree=%#"PRIx64"\n", ptr->d_id, ptr->no_child,
 (ptr->desc       ? ptr->desc->i_id       : (uint64_t)0),
 (ptr->assoc_tree ? ptr->assoc_tree->i_id : (uint64_t)0)));
 }
 DEBUG_RET();
 }
-void pst_printIDptr(pst_file* pf) {
+static void pst_printIDptr(pst_file* pf) {
 pst_index_ll *ptr = pf->i_head;
 DEBUG_ENT("pst_printIDptr");
 while (ptr) {
 DEBUG_INDEX(("%#"PRIx64" offset=%#"PRIx64" size=%#"PRIx64"\n", ptr->i_id, ptr->offset, ptr->size));
 ptr = ptr->next;
 }
 DEBUG_RET();
 }
-void pst_printID2ptr(pst_id2_ll *ptr) {
+static void pst_printID2ptr(pst_id2_ll *ptr) {
 DEBUG_ENT("pst_printID2ptr");
 while (ptr) {
 DEBUG_INDEX(("%#"PRIx64" id=%#"PRIx64"\n", ptr->id2, (ptr->id ? ptr->id->i_id : (uint64_t)0)));
 if (ptr->child) pst_printID2ptr(ptr->child);
 ptr = ptr->next;
 * @param size   size of the block to be read
 * @param buf    reference to pointer to buffer. If this pointer
 is non-NULL, it will first be free()d
 * @return       size of block read into memory
 */
-size_t pst_read_block_size(pst_file *pf, int64_t offset, size_t size, char **buf) {
+static size_t pst_read_block_size(pst_file *pf, int64_t offset, size_t size, char **buf) {
 size_t rsize;
 DEBUG_ENT("pst_read_block_size");
 DEBUG_READ(("Reading block from %#"PRIx64", %x bytes\n", offset, size));
 if (*buf) {
 DEBUG_RET();
 return 0;
 }
-uint64_t pst_getIntAt(pst_file *pf, char *buf) {
+static uint64_t pst_getIntAt(pst_file *pf, char *buf) {
 uint64_t buf64;
 uint32_t buf32;
 if (pf->do_read64) {
 memcpy(&buf64, buf, sizeof(buf64));
 LE64_CPU(buf64);
 return buf32;
 }
 }
-uint64_t pst_getIntAtPos(pst_file *pf, int64_t pos ) {
+static uint64_t pst_getIntAtPos(pst_file *pf, int64_t pos ) {
 uint64_t buf64;
 uint32_t buf32;
 if (pf->do_read64) {
 (void)pst_getAtPos(pf, pos, &buf64, sizeof(buf64));
 LE64_CPU(buf64);
 * @param pos  offset of the data in the pst file
 * @param buf  buffer to contain the data
 * @param size size of the buffer and the amount of data to be read
 * @return     actual read size, 0 if seek error
 */
+static size_t pst_getAtPos(pst_file *pf, int64_t pos, void* buf, size_t size) {
-size_t pst_getAtPos(pst_file *pf, int64_t pos, void* buf, size_t size) {
 size_t rc;
 DEBUG_ENT("pst_getAtPos");
 //  pst_block_recorder **t = &pf->block_head;
 //  pst_block_recorder *p = pf->block_head;
 //  while (p && ((p->offset+p->size) <= pos)) {
 DEBUG_RET();
 return rsize;
 }
-size_t pst_ff_getID2block(pst_file *pf, uint64_t id2, pst_id2_ll *id2_head, char** buf) {
+static size_t pst_ff_getID2block(pst_file *pf, uint64_t id2, pst_id2_ll *id2_head, char** buf) {
 size_t ret;
 pst_id2_ll* ptr;
 pst_holder h = {buf, NULL, 0};
 DEBUG_ENT("pst_ff_getID2block");
 ptr = pst_getID2(id2_head, id2);
 DEBUG_RET();
 return ret;
 }
-size_t pst_ff_getID2data(pst_file *pf, pst_index_ll *ptr, pst_holder *h) {
+static size_t pst_ff_getID2data(pst_file *pf, pst_index_ll *ptr, pst_holder *h) {
 size_t ret;
 char *b = NULL, *t;
 DEBUG_ENT("pst_ff_getID2data");
 if (!(ptr->i_id & 0x02)) {
 ret = pst_ff_getIDblock_dec(pf, ptr->i_id, &b);
 DEBUG_RET();
 return ret;
 }
-size_t pst_ff_compile_ID(pst_file *pf, uint64_t id, pst_holder *h, size_t size) {
+static size_t pst_ff_compile_ID(pst_file *pf, uint64_t id, pst_holder *h, size_t size) {
 size_t z, a;
 uint16_t count, y;
 char *buf3 = NULL, *buf2 = NULL, *t;
 char *b_ptr;
 int  line_count = 0;
 }
 #endif //_WIN32
-int pst_stricmp(char *a, char *b) {
+static int pst_stricmp(char *a, char *b) {
 // compare strings case-insensitive.
 // returns -1 if a < b, 0 if a==b, 1 if a > b
 while(*a != '\0' && *b != '\0' && toupper(*a)==toupper(*b)) {
 a++; b++;
 }
 else
 return 1;
 }
-int pst_strincmp(char *a, char *b, size_t x) {
+static int pst_strincmp(char *a, char *b, size_t x) {
 // compare upto x chars in string a and b case-insensitively
 // returns -1 if a < b, 0 if a==b, 1 if a > b
 size_t y = 0;
 while (*a != '\0' && *b != '\0' && y < x && toupper(*a)==toupper(*b)) {
 a++; b++; y++;
 DEBUG_RET();
 return r;
 }
-char * pst_wide_to_single(char *wt, size_t size) {
+static char* pst_wide_to_single(char *wt, size_t size) {
 // returns the first byte of each wide char. the size is the number of bytes in source
 char *x, *y;
 DEBUG_ENT("pst_wide_to_single");
 x = pst_malloc((size/2)+1);
 y = x;
 DEBUG_RET();
 return ret;
 }
-int pst_chr_count(char *str, char x) {
+static int pst_chr_count(char *str, char x) {
 int r = 0;
 while (*str) {
 if (*str == x) r++;
 str++;
 }

Mercurial > libpst

comparison src/libpst.c @ 176:ac6e22c8a9cf