lsm/mdbtools
1
0
Fork 0
mirror of https://github.com/mdbtools/mdbtools.git synced 2025-04-05 20:31:00 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
278cf8ef42
mdbtools/src/libmdb/data.c

1190 lines
30 KiB
C
Raw Blame History

/* MDB Tools - A library for reading MS Access database file
* Copyright (C) 2000 Brian Bruns
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "mdbtools.h"
#include "time.h"
#include "math.h"
#ifdef DMALLOC
#include "dmalloc.h"
#endif
#define MDB_DEBUG_OLE 0
#define OFFSET_MASK 0x1fff
char *mdb_money_to_string(MdbHandle *mdb, int start, char *s);
static int _mdb_attempt_bind(MdbHandle *mdb,
MdbColumn *col, unsigned char isnull, int offset, int len);
char *mdb_num_to_string(MdbHandle *mdb, int start, int datatype, int prec, int scale);
int mdb_copy_ole(MdbHandle *mdb, char *dest, int start, int size);
static char date_fmt[64] = "%x %X";
void mdb_set_date_fmt(const char *fmt)
{
date_fmt[63] = 0;
strncpy(date_fmt, fmt, 63);
}
void mdb_bind_column(MdbTableDef *table, int col_num, void *bind_ptr)
{
MdbColumn *col;
/*
** the column arrary is 0 based, so decrement to get 1 based parameter
*/
col=g_ptr_array_index(table->columns, col_num - 1);
col->bind_ptr = bind_ptr;
}
int
mdb_bind_column_by_name(MdbTableDef *table, gchar *col_name, void *bind_ptr)
{
int i, col_num = -1;
MdbColumn *col;
for (i=0;i<table->num_cols;i++) {
col=g_ptr_array_index(table->columns,i);
if (!strcmp(col->name,col_name))
col_num = col->col_num + 1;
}
mdb_bind_column(table, col_num, bind_ptr);
return col_num;
}
void mdb_bind_len(MdbTableDef *table, int col_num, int *len_ptr)
{
MdbColumn *col;
col=g_ptr_array_index(table->columns, col_num - 1);
col->len_ptr = len_ptr;
}
int
mdb_find_end_of_row(MdbHandle *mdb, int row)
{
MdbFormatConstants *fmt = mdb->fmt;
int row_end;
/* Search the previous "row start" values for the first non-'lookupflag' one.
* If we don't find one, then the end of the page is the correct value.
*/
#if 1
if (row==0) {
row_end = fmt->pg_size - 1;
} else {
row_end = (mdb_pg_get_int16(mdb, ((fmt->row_count_offset + 2) + (row - 1) * 2)) & OFFSET_MASK) - 1;
}
return row_end;
#else
int i, row_start;
/* if lookupflag is not set, it's good (deleteflag is ok) */
for (i = row - 1; i >= 0; i--) {
row_start = mdb_pg_get_int16(mdb, ((fmt->row_count_offset + 2) + i * 2));
if (!(row_start & 0x8000)) {
break;
}
}
if (i == -1) {
row_end = fmt->pg_size - 1;
} else {
row_end = (row_start & OFFSET_MASK) - 1;
}
return row_end;
#endif
}
int mdb_is_null(unsigned char *null_mask, int col_num)
{
int byte_num = (col_num - 1) / 8;
int bit_num = (col_num - 1) % 8;
if ((1 << bit_num) & null_mask[byte_num]) {
return 0;
} else {
return 1;
}
}
/* bool has to be handled specially because it uses the null bit to store its
** value*/
static int mdb_xfer_bound_bool(MdbHandle *mdb, MdbColumn *col, int value)
{
col->cur_value_len = value;
if (col->bind_ptr) {
strcpy(col->bind_ptr, value ? "0" : "1");
}
return 0;
}
static int mdb_xfer_bound_ole(MdbHandle *mdb, int start, MdbColumn *col, int len)
{
int ret;
if (len) {
col->cur_value_start = start;
col->cur_value_len = len;
} else {
col->cur_value_start = 0;
col->cur_value_len = 0;
}
if (col->bind_ptr || col->len_ptr) {
//ret = mdb_copy_ole(mdb, col->bind_ptr, start, len);
memcpy(col->bind_ptr, &mdb->pg_buf[start], MDB_MEMO_OVERHEAD);
}
if (col->len_ptr) {
*col->len_ptr = MDB_MEMO_OVERHEAD;
}
return ret;
}
static int mdb_xfer_bound_data(MdbHandle *mdb, int start, MdbColumn *col, int len)
{
int ret;
//if (!strcmp("Name",col->name)) {
//printf("start %d %d\n",start, len);
//}
if (len) {
col->cur_value_start = start;
col->cur_value_len = len;
} else {
col->cur_value_start = 0;
col->cur_value_len = 0;
}
if (col->bind_ptr) {
if (len) {
//fprintf(stdout,"len %d size %d\n",len, col->col_size);
if (col->col_type == MDB_NUMERIC) {
strcpy(col->bind_ptr,
mdb_num_to_string(mdb, start, col->col_type, col->col_prec, col->col_scale));
} else {
strcpy(col->bind_ptr,
mdb_col_to_string(mdb, mdb->pg_buf, start, col->col_type, len));
}
} else {
strcpy(col->bind_ptr, "");
}
ret = strlen(col->bind_ptr);
if (col->len_ptr) {
*col->len_ptr = ret;
}
return ret;
}
return 0;
}
int mdb_read_row(MdbTableDef *table, int row)
{
MdbHandle *mdb = table->entry->mdb;
MdbFormatConstants *fmt = mdb->fmt;
MdbColumn *col;
int i, rc;
//int num_cols, var_cols, fixed_cols;
int row_start, row_end;
//int fixed_cols_found, var_cols_found;
//int col_start, len, next_col;
//int num_of_jumps=0, jumps_used=0;
//int eod; /* end of data */
int delflag, lookupflag;
//int bitmask_sz;
//int col_ptr, deleted_columns=0;
//unsigned char null_mask[33]; /* 256 columns max / 8 bits per byte */
//unsigned char isnull;
MdbField fields[256];
int num_fields;
if (table->num_rows <= row)
return 0;
row_start = mdb_pg_get_int16(mdb, (fmt->row_count_offset + 2) + (row*2));
row_end = mdb_find_end_of_row(mdb, row);
delflag = lookupflag = 0;
if (row_start & 0x8000) lookupflag++;
if (row_start & 0x4000) delflag++;
row_start &= OFFSET_MASK; /* remove flags */
#if MDB_DEBUG
fprintf(stdout,"Row %d bytes %d to %d %s %s\n",
row, row_start, row_end,
lookupflag ? "[lookup]" : "",
delflag ? "[delflag]" : "");
#endif
if (!table->noskip_del && delflag) {
row_end = row_start-1;
return 0;
}
num_fields = mdb_crack_row(table, row_start, row_end, fields);
if (!mdb_test_sargs(table, fields, num_fields)) return 0;
#if MDB_DEBUG
fprintf(stdout,"sarg test passed row %d \n", row);
#endif
#if MDB_DEBUG
buffer_dump(mdb->pg_buf, row_start, row_end);
#endif
#if 1
/* take advantage of mdb_crack_row() to clean up binding */
for (i = 0; i < num_fields; i++) {
col = g_ptr_array_index(table->columns,fields[i].colnum);
if (fields[i].is_fixed) {
rc = _mdb_attempt_bind(mdb, col,
fields[i].is_null,
fields[i].start,
col->col_size);
} else {
rc = _mdb_attempt_bind(mdb, col,
fields[i].is_null,
fields[i].start,
fields[i].siz);
}
}
#endif
#if 0
/* find out all the important stuff about the row */
if (IS_JET4(mdb)) {
num_cols = mdb_pg_get_int16(mdb, row_start);
} else {
num_cols = mdb->pg_buf[row_start];
}
var_cols = 0; /* mdb->pg_buf[row_end-1]; */
fixed_cols = 0; /* num_cols - var_cols; */
for (j = 0; j < table->num_cols; j++) {
col = g_ptr_array_index (table->columns, j);
if (mdb_is_fixed_col(col))
fixed_cols++;
else
var_cols++;
}
bitmask_sz = (num_cols - 1) / 8 + 1;
if (IS_JET4(mdb)) {
eod = mdb_pg_get_int16(mdb, row_end - 3 - var_cols*2 - bitmask_sz);
} else {
eod = mdb->pg_buf[row_end-1-var_cols-bitmask_sz];
}
for (i=0;i<bitmask_sz;i++) {
null_mask[i]=mdb->pg_buf[row_end - bitmask_sz + i + 1];
}
#if MDB_DEBUG
fprintf(stdout,"#cols: %-3d #varcols %-3d EOD %-3d\n",
num_cols, var_cols, eod);
#endif
if (IS_JET4(mdb)) {
col_start = 2;
} else {
/* data starts at 1 */
col_start = 1;
}
fixed_cols_found = 0;
var_cols_found = 0;
/* fixed columns */
for (j=0;j<table->num_cols;j++) {
col = g_ptr_array_index(table->columns,j);
if (mdb_is_fixed_col(col) &&
++fixed_cols_found <= fixed_cols) {
/*
if (!strcmp(col->name, "Type")) {
printf("column Type, col_start %d row_start %d data %d %d\n",col_start, row_start, mdb->pg_buf[row_start + col_start], mdb->pg_buf[row_start + col_start + 1]);
}
*/
isnull = mdb_is_null(null_mask, j+1);
rc = _mdb_attempt_bind(mdb, col, isnull,
row_start + col_start, col->col_size);
if (!rc) return 0;
if (col->col_type != MDB_BOOL)
col_start += col->col_size;
}
}
/* if fixed columns add up to more than 256, we need a jump */
if (IS_JET3(mdb) && col_start >= 256) {
num_of_jumps++;
jumps_used++;
row_start = row_start + col_start - (col_start % 256);
}
col_start = row_start;
/* */
while (col_start+256 < row_end-bitmask_sz-1-var_cols-num_of_jumps){
col_start += 256;
num_of_jumps++;
}
if (IS_JET4(mdb)) {
col_ptr = row_end - 2 - bitmask_sz - 1;
eod = mdb_pg_get_int16(mdb, col_ptr - var_cols*2);
col_start = mdb_pg_get_int16(mdb, col_ptr);
} else {
col_ptr = row_end - bitmask_sz - num_of_jumps - 1;
if (mdb->pg_buf[col_ptr]==0xFF) {
col_ptr--;
deleted_columns++;
}
eod = mdb->pg_buf[col_ptr - var_cols];
col_start = mdb->pg_buf[col_ptr];
}
#if MDB_DEBUG
fprintf(stdout,"col_start %d num_of_jumps %d\n",
col_start, num_of_jumps);
#endif
/* variable columns */
for (j=0;j<table->num_cols;j++) {
col = g_ptr_array_index(table->columns,j);
if (!mdb_is_fixed_col(col) &&
++var_cols_found <= var_cols) {
/* col_start = mdb->pg_buf[row_end-bitmask_sz-var_cols_found]; */
/* more code goes here but the diff is mangled */
/*
if (var_cols_found == mdb->pg_buf[row_end-bitmask_sz-jumps_used-1] &&
jumps_used < num_of_jumps) {
row_start += 256;
col_start -= 256;
jumps_used++;
}
*/
if (var_cols_found==var_cols) {
len=eod - col_start;
} else {
if (IS_JET4(mdb)) {
//next_col = mdb_pg_get_int16(mdb, row_end - bitmask_sz - var_cols_found * 2 - 2 - 1) ;
next_col = mdb->pg_buf[row_end - bitmask_sz - var_cols_found * 2 - 2] * 256 +
mdb->pg_buf[row_end - bitmask_sz - var_cols_found * 2 - 2 - 1] ;
len = next_col - col_start;
/* len=mdb->pg_buf[row_end - bitmask_sz - var_cols_found * 2
- 2 - 1] - col_start; */
//len=mdb->pg_buf[row_end - bitmask_sz - var_cols_found * 2
//- 2 - 1 - num_of_jumps * 2] - col_start;
/*
fprintf(stdout, "found %d fix %d new pos %d new start %d old start %d\n",
var_cols_found,
row_end - bitmask_sz - var_cols_found * 2
- 2 - 1,
row_end - bitmask_sz - var_cols_found * 2
- 2 - 1 - num_of_jumps * 2,
mdb->pg_buf[row_end - bitmask_sz - var_cols_found * 2
- 2 - 1], col_start);
*/
} else {
len=mdb->pg_buf[col_ptr - var_cols_found ] - col_start;
}
if (len<0)
len+=256;
}
isnull = mdb_is_null(null_mask, j+1);
#if MDB_DEBUG
printf("binding len %d isnull %d col_start %d row_start %d row_end %d bitmask %d var_cols_found %d buf %d\n", len, isnull,col_start,row_start,row_end, bitmask_sz, var_cols_found, mdb->pg_buf[row_end - bitmask_sz - var_cols_found * 2 - 1 - num_of_jumps ]);
#endif
rc = _mdb_attempt_bind(mdb, col, isnull,
row_start + col_start, len);
if (!rc) return 0;
col_start += len;
}
}
#endif
return 1;
}
static int _mdb_attempt_bind(MdbHandle *mdb,
MdbColumn *col,
unsigned char isnull,
int offset,
int len)
{
if (col->col_type == MDB_BOOL) {
mdb_xfer_bound_bool(mdb, col, isnull);
} else if (isnull) {
mdb_xfer_bound_data(mdb, 0, col, 0);
} else if (col->col_type == MDB_OLE) {
mdb_xfer_bound_ole(mdb, offset, col, len);
} else {
//if (!mdb_test_sargs(mdb, col, offset, len)) {
//return 0;
//}
mdb_xfer_bound_data(mdb, offset, col, len);
}
return 1;
}
int
mdb_read_next_dpg_by_map0(MdbTableDef *table)
{
MdbCatalogEntry *entry = table->entry;
MdbHandle *mdb = entry->mdb;
int pgnum, i, bitn;
pgnum = mdb_get_int32(table->usage_map,1);
/* the first 5 bytes of the usage map mean something */
for (i=5;i<table->map_sz;i++) {
for (bitn=0;bitn<8;bitn++) {
if (table->usage_map[i] & 1 << bitn && pgnum > table->cur_phys_pg) {
table->cur_phys_pg = pgnum;
if (!mdb_read_pg(mdb, pgnum)) {
return 0;
} else {
return pgnum;
}
}
pgnum++;
}
}
/* didn't find anything */
return 0;
}
int
mdb_read_next_dpg_by_map1(MdbTableDef *table)
{
MdbCatalogEntry *entry = table->entry;
MdbHandle *mdb = entry->mdb;
guint32 pgnum, i, j, bitn, map_pg, map_ind, offset, bit_offset;
/*
* table->cur_phys_pg will tell us where to (re)start the scan
* for the next data page. each usage_map entry points to a
* 0x05 page which bitmaps (mdb->fmt->pg_size - 4) * 8 pages.
*
* map_ind gives us the starting usage_map entry
* offset gives us a page offset into the bitmap (must be converted
* to bytes and bits).
*/
pgnum = table->cur_phys_pg + 1;
map_ind = pgnum / ((mdb->fmt->pg_size - 4) * 8);
offset = pgnum % ((mdb->fmt->pg_size - 4) * 8);
bit_offset = offset % 8;
//printf("map size %ld\n", table->map_sz);
for (i = 4 * map_ind + 1;i < table->map_sz-1; i += 4) {
map_pg = mdb_get_int32(table->usage_map, i);
//printf("loop %d pg %ld %02x%02x%02x%02x\n",i, map_pg,table->usage_map[i],table->usage_map[i+1],table->usage_map[i+2],table->usage_map[i+3]);
/* if the usage_map entry is empty, skip it, but advance the page counter */
if (!map_pg) {
pgnum += (mdb->fmt->pg_size - 4) * 8;
continue;
}
if(mdb_read_alt_pg(mdb, map_pg) != mdb->fmt->pg_size) {
fprintf(stderr, "Oops! didn't get a full page at %d\n", map_pg);
exit(1);
}
//printf("reading page %ld\n",map_pg);
/* first time through, start j, bitn based on the starting offset
* after that, reset offset to 0 to start at the beginning of the page/byte
*/
for (j=4 + offset;j<mdb->fmt->pg_size;j++) {
for (bitn=bit_offset;bitn<8;bitn++) {
if (mdb->alt_pg_buf[j] & 1 << bitn && pgnum > table->cur_phys_pg) {
table->cur_phys_pg = pgnum;
if (!mdb_read_pg(mdb, pgnum)) {
return 0;
} else {
//printf("page found at %04x %d\n",pgnum, pgnum);
return pgnum;
}
}
pgnum++;
}
bit_offset = 0;
}
offset = 0;
}
/* didn't find anything */
//printf("returning 0\n");
return 0;
}
int
mdb_read_next_dpg(MdbTableDef *table)
{
MdbCatalogEntry *entry = table->entry;
MdbHandle *mdb = entry->mdb;
int map_type;
#ifndef SLOW_READ
map_type = table->usage_map[0];
if (map_type==0) {
return mdb_read_next_dpg_by_map0(table);
} else if (map_type==1) {
return mdb_read_next_dpg_by_map1(table);
} else {
fprintf(stderr,"Warning: unrecognized usage map type: %d, defaulting to brute force read\n",table->usage_map[0]);
}
#endif
/* can't do a fast read, go back to the old way */
do {
if (!mdb_read_pg(mdb, table->cur_phys_pg++))
return 0;
} while (mdb->pg_buf[0]!=0x01 || mdb_pg_get_int32(mdb, 4)!=entry->table_pg);
/* fprintf(stderr,"returning new page %ld\n", table->cur_phys_pg); */
return table->cur_phys_pg;
}
int mdb_rewind_table(MdbTableDef *table)
{
table->cur_pg_num=0;
table->cur_phys_pg=0;
table->cur_row=0;
return 0;
}
int mdb_fetch_row(MdbTableDef *table)
{
MdbHandle *mdb = table->entry->mdb;
MdbFormatConstants *fmt = mdb->fmt;
int rows;
int rc;
guint32 pg;
if (table->num_rows==0)
return 0;
/* initialize */
if (!table->cur_pg_num) {
table->cur_pg_num=1;
table->cur_row=0;
if (table->strategy!=MDB_INDEX_SCAN)
if (!mdb_read_next_dpg(table)) return 0;
}
do {
if (table->strategy==MDB_INDEX_SCAN) {
if (!mdb_index_find_next(table->mdbidx, table->scan_idx, table->chain, &pg, (guint16 *) &(table->cur_row))) {
mdb_index_scan_free(table);
return 0;
}
mdb_read_pg(mdb, pg);
} else {
rows = mdb_pg_get_int16(mdb,fmt->row_count_offset);
/* if at end of page, find a new page */
if (table->cur_row >= rows) {
table->cur_row=0;
if (!mdb_read_next_dpg(table)) {
return 0;
}
}
}
/* printf("page %d row %d\n",table->cur_phys_pg, table->cur_row); */
rc = mdb_read_row(table, table->cur_row);
table->cur_row++;
} while (!rc);
return 1;
}
void mdb_data_dump(MdbTableDef *table)
{
int i, j;
char *bound_values[MDB_MAX_COLS];
for (i=0;i<table->num_cols;i++) {
bound_values[i] = (char *) malloc(256);
mdb_bind_column(table, i+1, bound_values[i]);
}
mdb_rewind_table(table);
while (mdb_fetch_row(table)) {
for (j=0;j<table->num_cols;j++) {
fprintf(stdout, "column %d is %s\n", j+1, bound_values[j]);
}
}
for (i=0;i<table->num_cols;i++) {
free(bound_values[i]);
}
}
int mdb_is_fixed_col(MdbColumn *col)
{
return col->is_fixed;
}
#if 0
static char *mdb_data_to_hex(MdbHandle *mdb, char *text, int start, int size)
{
int i;
for (i=start; i<start+size; i++) {
sprintf(&text[(i-start)*2],"%02x", mdb->pg_buf[i]);
}
text[(i-start)*2]='\0';
return text;
}
#endif
int
mdb_ole_read_next(MdbHandle *mdb, MdbColumn *col, void *ole_ptr)
{
guint16 ole_len;
guint16 ole_flags;
int row_stop, row_start;
int len;
ole_len = mdb_get_int16(ole_ptr, 0);
ole_flags = mdb_get_int16(ole_ptr, 2);
if (ole_flags == 0x8000) {
/* inline fields don't have a next */
return 0;
} else if (ole_flags == 0x4000) {
/* 0x4000 flagged ole's are contained on one page and thus
* should be handled entirely with mdb_ole_read() */
return 0;
} else if (ole_flags == 0x0000) {
if(mdb_read_alt_pg(mdb, col->cur_blob_pg) != mdb->fmt->pg_size) {
/* Failed to read */
return 0;
}
/* swap the alt and regular page buffers, so we can call get_int16 */
mdb_swap_pgbuf(mdb);
row_stop = mdb_find_end_of_row(mdb, col->cur_blob_row);
row_start = mdb_pg_get_int16(mdb, 10 + col->cur_blob_row * 2);
len = row_stop - row_start;
if (col->bind_ptr)
memcpy(col->bind_ptr, &mdb->pg_buf[row_start], len);
col->cur_blob_row = mdb->pg_buf[row_start];
col->cur_blob_pg = mdb_pg_get_int24(mdb, row_start+1);
/* make sure to swap page back */
mdb_swap_pgbuf(mdb);
return len;
}
return 0;
}
int
mdb_ole_read(MdbHandle *mdb, MdbColumn *col, void *ole_ptr, int chunk_size)
{
guint16 ole_len;
guint16 ole_flags;
int row_stop, row_start;
int len;
ole_len = mdb_get_int16(ole_ptr, 0);
ole_flags = mdb_get_int16(ole_ptr, 2);
#if MDB_DEBUG_OLE
printf("ole len = %d ole flags = %08x\n", ole_len, ole_flags);
#endif
col->chunk_size = chunk_size;
if (ole_flags == 0x8000) {
/* inline ole field, if we can satisfy it, then do it */
len = col->cur_value_len - MDB_MEMO_OVERHEAD;
if (chunk_size >= len) {
if (col->bind_ptr)
memcpy(col->bind_ptr,
&mdb->pg_buf[col->cur_value_start +
MDB_MEMO_OVERHEAD],
len);
return len;
} else {
return 0;
}
} else if (ole_flags == 0x4000) {
col->cur_blob_row = ((char *)ole_ptr)[4];
col->cur_blob_pg = mdb_get_int24(ole_ptr, 5);
#if MDB_DEBUG_OLE
printf("ole row = %d ole pg = %ld\n", col->cur_blob_row, col->cur_blob_pg);
#endif
if(mdb_read_alt_pg(mdb, col->cur_blob_pg) != mdb->fmt->pg_size) {
/* Failed to read */
return 0;
}
/* swap the alt and regular page buffers, so we can call get_int16 */
mdb_swap_pgbuf(mdb);
row_stop = mdb_find_end_of_row(mdb, col->cur_blob_row);
row_start = mdb_pg_get_int16(mdb, 10 + col->cur_blob_row * 2);
len = row_stop - row_start + 1;
#if MDB_DEBUG_OLE
printf("start %d stop %d len %d\n", row_start, row_stop, len);
#endif
if (col->bind_ptr) {
memcpy(col->bind_ptr, &mdb->pg_buf[row_start], len);
#if MDB_DEBUG_OLE
buffer_dump(col->bind_ptr, 0, 16);
#endif
}
/* make sure to swap page back */
mdb_swap_pgbuf(mdb);
return len;
} else if (ole_flags == 0x0000) {
col->cur_blob_row = ((char *)ole_ptr)[4];
col->cur_blob_pg = mdb_get_int24(ole_ptr, 5);
if(mdb_read_alt_pg(mdb, col->cur_blob_pg) != mdb->fmt->pg_size) {
/* Failed to read */
return 0;
}
/* swap the alt and regular page buffers, so we can call get_int16 */
mdb_swap_pgbuf(mdb);
row_stop = mdb_find_end_of_row(mdb, col->cur_blob_row);
row_start = mdb_pg_get_int16(mdb, 10 + col->cur_blob_row * 2);
len = row_stop - row_start;
if (col->bind_ptr)
memcpy(col->bind_ptr, &mdb->pg_buf[row_start], len);
col->cur_blob_row = mdb->pg_buf[row_start];
col->cur_blob_pg = mdb_pg_get_int24(mdb, row_start+1);
/* make sure to swap page back */
mdb_swap_pgbuf(mdb);
return len;
} else {
fprintf(stderr,"Unhandled ole field flags = %04x\n", ole_flags);
return 0;
}
}
int mdb_copy_ole(MdbHandle *mdb, char *dest, int start, int size)
{
guint16 ole_len;
guint16 ole_flags;
guint16 row_start, row_stop;
guint8 ole_row;
guint32 lval_pg;
guint16 len, cur;
if (size<MDB_MEMO_OVERHEAD) {
return 0;
}
ole_len = mdb_pg_get_int16(mdb, start);
ole_flags = mdb_pg_get_int16(mdb, start+2);
if (ole_flags == 0x8000) {
len = size - MDB_MEMO_OVERHEAD;
/* inline ole field */
if (dest) memcpy(dest, &mdb->pg_buf[start + MDB_MEMO_OVERHEAD],
size - MDB_MEMO_OVERHEAD);
return len;
} else if (ole_flags == 0x4000) {
/* The 16 bit integer at offset 0 is the length of the memo field.
* The 24 bit integer at offset 5 is the page it is stored on.
*/
ole_row = mdb->pg_buf[start+4];
lval_pg = mdb_pg_get_int24(mdb, start+5);
#if MDB_DEBUG_OLE
printf("Reading LVAL page %06x\n", lval_pg);
#endif
if(mdb_read_alt_pg(mdb, lval_pg) != mdb->fmt->pg_size) {
/* Failed to read */
return 0;
}
/* swap the alt and regular page buffers, so we can call get_int16 */
mdb_swap_pgbuf(mdb);
if (ole_row) {
row_stop = mdb_pg_get_int16(mdb, 10 + (ole_row - 1) * 2) & 0x0FFF;
} else {
row_stop = mdb->fmt->pg_size - 1;
}
row_start = mdb_pg_get_int16(mdb, 10 + ole_row * 2);
#if MDB_DEBUG_OLE
printf("row num %d row start %d row stop %d\n", ole_row, row_start, row_stop);
#endif
len = row_stop - row_start;
if (dest) memcpy(dest, &mdb->pg_buf[row_start], len);
/* make sure to swap page back */
mdb_swap_pgbuf(mdb);
return len;
} else if (ole_flags == 0x0000) {
ole_row = mdb->pg_buf[start+4];
lval_pg = mdb_pg_get_int24(mdb, start+5);
#if MDB_DEBUG_OLE
printf("Reading LVAL page %06x\n", lval_pg);
#endif
/* swap the alt and regular page buffers, so we can call get_int16 */
mdb_swap_pgbuf(mdb);
cur=0;
do {
if(mdb_read_pg(mdb, lval_pg) != mdb->fmt->pg_size) {
/* Failed to read */
return 0;
}
if (ole_row) {
row_stop = mdb_pg_get_int16(mdb, 10 + (ole_row - 1) * 2) & 0x0FFF;
} else {
row_stop = mdb->fmt->pg_size - 1;
}
row_start = mdb_pg_get_int16(mdb, 10 + ole_row * 2);
#if MDB_DEBUG_OLE
printf("row num %d row start %d row stop %d\n", ole_row, row_start, row_stop);
#endif
len = row_stop - row_start;
if (dest)
memcpy(&dest[cur], &mdb->pg_buf[row_start+4],
len - 4);
cur += len - 4;
/* find next lval page */
ole_row = mdb->pg_buf[row_start];
lval_pg = mdb_pg_get_int24(mdb, row_start+1);
} while (lval_pg);
/* make sure to swap page back */
mdb_swap_pgbuf(mdb);
return cur;
} else {
fprintf(stderr,"Unhandled ole field flags = %04x\n", ole_flags);
return 0;
}
}
static char *mdb_memo_to_string(MdbHandle *mdb, int start, int size)
{
MdbFormatConstants *fmt = mdb->fmt;
guint16 memo_len;
static char text[MDB_BIND_SIZE];
guint16 memo_flags;
guint16 row_start, row_stop;
guint8 memo_row;
guint32 lval_pg;
guint16 len;
if (size<MDB_MEMO_OVERHEAD) {
return "";
}
#if MDB_DEBUG
buffer_dump(mdb->pg_buf, start, start + 12);
#endif
memo_len = mdb_pg_get_int16(mdb, start);
memo_flags = mdb_pg_get_int16(mdb, start+2);
if (memo_flags & 0x8000) {
/* inline memo field */
strncpy(text, &mdb->pg_buf[start + MDB_MEMO_OVERHEAD],
size - MDB_MEMO_OVERHEAD);
text[size - MDB_MEMO_OVERHEAD]='\0';
return text;
} else if (memo_flags & 0x4000) {
/* The 16 bit integer at offset 0 is the length of the memo field.
* The 24 bit integer at offset 5 is the page it is stored on.
*/
memo_row = mdb->pg_buf[start+4];
lval_pg = mdb_pg_get_int24(mdb, start+5);
#if MDB_DEBUG
printf("Reading LVAL page %06x\n", lval_pg);
#endif
if(mdb_read_alt_pg(mdb, lval_pg) != fmt->pg_size) {
/* Failed to read */
return "";
}
/* swap the alt and regular page buffers, so we can call get_int16 */
mdb_swap_pgbuf(mdb);
if (memo_row) {
row_stop = mdb_pg_get_int16(mdb, fmt->row_count_offset + 2 + (memo_row - 1) * 2) & 0x0FFF;
} else {
row_stop = fmt->pg_size - 1;
}
row_start = mdb_pg_get_int16(mdb, fmt->row_count_offset + 2 + memo_row * 2);
#if MDB_DEBUG
printf("row num %d row start %d row stop %d\n", memo_row, row_start, row_stop);
buffer_dump(mdb->pg_buf,row_start, row_start + len);
#endif
len = row_stop - row_start;
if (IS_JET3(mdb)) {
strncpy(text, &mdb->pg_buf[row_start], len);
text[len]='\0';
} else {
mdb_unicode2ascii(mdb, mdb->pg_buf, row_start, len, text);
#if 0
if (mdb->pg_buf[row_start]==0xff &&
mdb->pg_buf[row_start+1]==0xfe) {
strncpy(text, &mdb->pg_buf[row_start+2], len-2);
text[len-2]='\0';
} else {
/* convert unicode to ascii, rather sloppily */
for (i=0;i<len;i+=2)
text[i/2] = mdb->pg_buf[row_start + i];
text[len/2]='\0';
}
#endif
}
/* make sure to swap page back */
mdb_swap_pgbuf(mdb);
return text;
} else { /* if (memo_flags == 0x0000) { */
memo_row = mdb->pg_buf[start+4];
lval_pg = mdb_pg_get_int24(mdb, start+5);
#if MDB_DEBUG
printf("Reading LVAL page %06x\n", lval_pg);
#endif
/* swap the alt and regular page buffers, so we can call get_int16 */
mdb_swap_pgbuf(mdb);
text[0]='\0';
do {
if(mdb_read_pg(mdb, lval_pg) != fmt->pg_size) {
/* Failed to read */
return "";
}
if (memo_row) {
row_stop = mdb_pg_get_int16(mdb, 10 + (memo_row - 1) * 2) & 0x0FFF;
} else {
row_stop = fmt->pg_size - 1;
}
row_start = mdb_pg_get_int16(mdb, 10 + memo_row * 2);
#if MDB_DEBUG
printf("row num %d row start %d row stop %d\n", memo_row, row_start, row_stop);
#endif
len = row_stop - row_start;
strncat(text, &mdb->pg_buf[row_start+4],
strlen(text) + len - 4 > MDB_BIND_SIZE ?
MDB_BIND_SIZE - strlen(text) :
len - 4);
/* find next lval page */
memo_row = mdb->pg_buf[row_start];
lval_pg = mdb_pg_get_int24(mdb, row_start+1);
} while (lval_pg);
/* make sure to swap page back */
mdb_swap_pgbuf(mdb);
return text;
/*
} else {
fprintf(stderr,"Unhandled memo field flags = %04x\n", memo_flags);
return "";
*/
}
}
char *
mdb_num_to_string(MdbHandle *mdb, int start, int datatype, int prec, int scale)
{
/* FIX ME -- not thread safe */
static char text[MDB_BIND_SIZE];
char tmpbuf[MDB_BIND_SIZE];
char mask[20];
gint32 l;
l = mdb->pg_buf[start+16] * 256 * 256 * 256 +
mdb->pg_buf[start+15] * 256 * 256 +
mdb->pg_buf[start+14] * 256 +
mdb->pg_buf[start+13];
sprintf(mask,"%%0%dld",prec);
sprintf(tmpbuf,mask,l);
//strcpy(text, tmpbuf);
//return text;
if (!scale) {
strcpy(text,tmpbuf);
} else {
memset(text,0,sizeof(text));
strncpy(text,tmpbuf,prec-scale);
strcat(text,".");
strcat(text,&tmpbuf[strlen(tmpbuf)-scale]);
}
return text;
}
static int trim_trailing_zeros(char * buff, int n)
{
char * p = buff + n - 1;
while (p >= buff && *p == '0')
*p-- = '\0';
if (*p == '.')
*p = '\0';
return 0;
}
char *mdb_col_to_string(MdbHandle *mdb, unsigned char *buf, int start, int datatype, int size)
{
/* FIX ME -- not thread safe */
static char text[MDB_BIND_SIZE];
time_t t;
int i, n;
float tf;
double td;
switch (datatype) {
case MDB_BOOL:
/* shouldn't happen. bools are handled specially
** by mdb_xfer_bound_bool() */
break;
case MDB_BYTE:
sprintf(text,"%d",mdb_get_byte(buf, start));
return text;
break;
case MDB_INT:
sprintf(text,"%ld",(long)mdb_get_int16(buf, start));
return text;
break;
case MDB_LONGINT:
sprintf(text,"%ld",mdb_get_int32(buf, start));
return text;
break;
case MDB_FLOAT:
tf = mdb_get_single(mdb->pg_buf, start);
n = sprintf(text,"%.*f",FLT_DIG - (int)ceil(log10(tf)), tf);
trim_trailing_zeros(text, n);
return text;
break;
case MDB_DOUBLE:
td = mdb_get_double(mdb->pg_buf, start);
n = sprintf(text,"%.*f",DBL_DIG - (int)ceil(log10(td)), td);
trim_trailing_zeros(text, n);
return text;
break;
case MDB_TEXT:
if (size<0) {
return "";
}
if (IS_JET4(mdb)) {
/*
for (i=0;i<size;i++) {
fprintf(stdout, "%c %02x ", mdb->pg_buf[start+i], mdb->pg_buf[start+i]);
}
fprintf(stdout, "\n");
*/
if (mdb->pg_buf[start]==0xff &&
mdb->pg_buf[start+1]==0xfe) {
strncpy(text, &mdb->pg_buf[start+2], size-2);
text[size-2]='\0';
} else {
/* convert unicode to ascii, rather sloppily */
for (i=0;i<size;i+=2)
text[i/2] = mdb->pg_buf[start + i];
text[size/2]='\0';
}
} else {
strncpy(text, &buf[start], size);
text[size]='\0';
}
return text;
break;
case MDB_SDATETIME:
t = (long int)((mdb_get_double(buf, start) - 25569.0) * 86400.0);
strftime(text, MDB_BIND_SIZE, date_fmt,
(struct tm*)gmtime(&t));
return text;
break;
case MDB_MEMO:
return mdb_memo_to_string(mdb, start, size);
break;
case MDB_MONEY:
mdb_money_to_string(mdb, start, text);
return text;
case MDB_NUMERIC:
break;
default:
return "";
break;
}
return NULL;
}
int mdb_col_disp_size(MdbColumn *col)
{
switch (col->col_type) {
case MDB_BOOL:
return 1;
break;
case MDB_BYTE:
return 3;
break;
case MDB_INT:
return 5;
break;
case MDB_LONGINT:
return 7;
break;
case MDB_FLOAT:
return 10;
break;
case MDB_DOUBLE:
return 10;
break;
case MDB_TEXT:
return col->col_size;
break;
case MDB_SDATETIME:
return 20;
break;
case MDB_MEMO:
return 255;
break;
case MDB_MONEY:
return 12;
break;
}
return 0;
}
int mdb_col_fixed_size(MdbColumn *col)
{
switch (col->col_type) {
case MDB_BOOL:
return 1;
break;
case MDB_BYTE:
return -1;
break;
case MDB_INT:
return 2;
break;
case MDB_LONGINT:
return 4;
break;
case MDB_FLOAT:
return 4;
break;
case MDB_DOUBLE:
return 8;
break;
case MDB_TEXT:
return -1;
break;
case MDB_SDATETIME:
return 4;
break;
case MDB_MEMO:
return -1;
break;
case MDB_MONEY:
return 8;
break;
}
return 0;
}
int
mdb_unicode2ascii(MdbHandle *mdb, unsigned char *buf, int offset, int len, char *dest)
{
int i;
if (buf[offset]==0xff &&
buf[offset+1]==0xfe) {
strncpy(dest, &buf[offset+2], len-2);
dest[len-2]='\0';
} else {
/* convert unicode to ascii, rather sloppily */
for (i=0;i<len;i+=2)
dest[i/2] = buf[offset + i];
dest[len/2]='\0';
}
return len;
}
Reference in New Issue View Git Blame Copy Permalink