void bin_load(uint4 begin, uint4 end)
{
unsigned char *ptr, *cp1, *cp2, *btop, *gvkey_char_ptr, *tmp_ptr, *tmp_key_ptr, *c, *ctop;
unsigned char hdr_lvl, src_buff[MAX_KEY_SZ + 1], dest_buff[MAX_ZWR_KEY_SZ],
cmpc_str[MAX_KEY_SZ + 1], dup_key_str[MAX_KEY_SZ + 1];
unsigned char *end_buff;
unsigned short rec_len, next_cmpc;
int len;
int current, last, length, max_blk_siz, max_key, status;
uint4 iter, max_data_len, max_subsc_len, key_count;
ssize_t rec_count, global_key_count, subsc_len,extr_std_null_coll;
boolean_t need_xlation, new_gvn, utf8_extract;
rec_hdr *rp, *next_rp;
mval v, tmp_mval;
mstr mstr_src, mstr_dest;
collseq *extr_collseq, *db_collseq, *save_gv_target_collseq;
coll_hdr extr_collhdr, db_collhdr;
gv_key *tmp_gvkey = NULL; /* null-initialize at start, will be malloced later */
char std_null_coll[BIN_HEADER_NUMSZ + 1];
# ifdef GTM_CRYPT
gtmcrypt_key_t *encr_key_handles;
char *inbuf;
int4 index;
int req_dec_blk_size, init_status, crypt_status;
muext_hash_hdr_ptr_t hash_array = NULL;
# endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(4 == SIZEOF(coll_hdr));
gvinit();
v.mvtype = MV_STR;
len = file_input_bin_get((char **)&ptr);
hdr_lvl = EXTR_HEADER_LEVEL(ptr);
if (!(((('4' == hdr_lvl) || ('5' == hdr_lvl)) && (BIN_HEADER_SZ == len)) || (('4' > hdr_lvl) && (V3_BIN_HEADER_SZ == len))))
{
rts_error(VARLSTCNT(1) ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
/* expecting the level in a single character */
assert(' ' == *(ptr + SIZEOF(BIN_HEADER_LABEL) - 3));
if (0 != memcmp(ptr, BIN_HEADER_LABEL, SIZEOF(BIN_HEADER_LABEL) - 2) || ('2' > hdr_lvl) || *(BIN_HEADER_VERSION) < hdr_lvl)
{ /* ignore the level check */
rts_error(VARLSTCNT(1) ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
/* check if extract was generated in UTF-8 mode */
utf8_extract = (0 == MEMCMP_LIT(&ptr[len - BIN_HEADER_LABELSZ], UTF8_NAME)) ? TRUE : FALSE;
if ((utf8_extract && !gtm_utf8_mode) || (!utf8_extract && gtm_utf8_mode))
{ /* extract CHSET doesn't match $ZCHSET */
if (utf8_extract)
rts_error(VARLSTCNT(4) ERR_LOADINVCHSET, 2, LEN_AND_LIT("UTF-8"));
else
rts_error(VARLSTCNT(4) ERR_LOADINVCHSET, 2, LEN_AND_LIT("M"));
mupip_exit(ERR_LDBINFMT);
}
if ('4' >= hdr_lvl)
{ /* Binary extracts in V50000-to-V52000 (label=4) and pre-V50000 (label=3) could have a '\0' byte (NULL byte)
* in the middle of the string. Replace it with ' ' (space) like it would be in V52000 binary extracts and above.
*/
for (c = ptr, ctop = c + len; c < ctop; c++)
{
if ('\0' == *c)
*c = ' ';
}
}
util_out_print("Label = !AD\n", TRUE, len, ptr);
new_gvn = FALSE;
if (hdr_lvl > '3')
{
memcpy(std_null_coll, ptr + BIN_HEADER_NULLCOLLOFFSET, BIN_HEADER_NUMSZ);
std_null_coll[BIN_HEADER_NUMSZ] = '\0';
extr_std_null_coll = STRTOUL(std_null_coll, NULL, 10);
if (0 != extr_std_null_coll && 1!= extr_std_null_coll)
{
rts_error(VARLSTCNT(5) ERR_TEXT, 2, RTS_ERROR_TEXT("Corrupted null collation field in header"),
ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
} else
extr_std_null_coll = 0;
# ifdef GTM_CRYPT
if ('5' <= hdr_lvl)
{
int i, num_indexes;
len = file_input_bin_get((char **)&ptr);
hash_array = (muext_hash_hdr *)malloc(len);
/* store hashes of all the files used during extract into muext_hash_hdr structure */
memcpy((char *)hash_array, ptr, len);
num_indexes = len / GTMCRYPT_HASH_LEN;
encr_key_handles = (gtmcrypt_key_t *)malloc(SIZEOF(gtmcrypt_key_t) * num_indexes);
INIT_PROC_ENCRYPTION(crypt_status);
GC_BIN_LOAD_ERR(crypt_status);
for (index = 0; index < num_indexes; index++)
{
if (0 == memcmp(hash_array[index].gtmcrypt_hash, EMPTY_GTMCRYPT_HASH, GTMCRYPT_HASH_LEN))
continue;
GTMCRYPT_GETKEY(hash_array[index].gtmcrypt_hash, encr_key_handles[index], crypt_status);
GC_BIN_LOAD_ERR(crypt_status);
}
}
# endif
if ('2' < hdr_lvl)
{
len = file_input_bin_get((char **)&ptr);
if (SIZEOF(coll_hdr) != len)
{
rts_error(VARLSTCNT(5) ERR_TEXT, 2, RTS_ERROR_TEXT("Corrupt collation header"), ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
extr_collhdr = *((coll_hdr *)(ptr));
new_gvn = TRUE;
} else
gtm_putmsg(VARLSTCNT(3) ERR_OLDBINEXTRACT, 1, hdr_lvl - '0');
if (begin < 2)
begin = 2;
for (iter = 2; iter < begin; iter++)
{
if (!(len = file_input_bin_get((char **)&ptr)))
{
gtm_putmsg(VARLSTCNT(3) ERR_LOADEOF, 1, begin);
util_out_print("Error reading record number: !UL\n", TRUE, iter);
mupip_error_occurred = TRUE;
return;
} else if (len == SIZEOF(coll_hdr))
{
extr_collhdr = *((coll_hdr *)(ptr));
assert(hdr_lvl > '2');
iter--;
}
}
assert(iter == begin);
util_out_print("Beginning LOAD at record number: !UL\n", TRUE, begin);
max_data_len = 0;
max_subsc_len = 0;
global_key_count = key_count = 0;
rec_count = begin - 1;
extr_collseq = db_collseq = NULL;
need_xlation = FALSE;
assert(NULL == tmp_gvkey); /* GVKEY_INIT macro relies on this */
GVKEY_INIT(tmp_gvkey, DBKEYSIZE(MAX_KEY_SZ)); /* tmp_gvkey will point to malloced memory after this */
for (; !mupip_DB_full ;)
{
if (++rec_count > end)
break;
next_cmpc = 0;
mupip_error_occurred = FALSE;
if (mu_ctrly_occurred)
break;
if (mu_ctrlc_occurred)
{
util_out_print("!AD:!_ Key cnt: !UL max subsc len: !UL max data len: !UL", TRUE,
LEN_AND_LIT(gt_lit), key_count, max_subsc_len, max_data_len);
util_out_print("Last LOAD record number: !UL", TRUE, key_count ? (rec_count - 1) : 0);
mu_gvis();
util_out_print(0, TRUE);
mu_ctrlc_occurred = FALSE;
}
/* reset the stringpool for every record in order to avoid garbage collection */
stringpool.free = stringpool.base;
if (!(len = file_input_bin_get((char **)&ptr)) || mupip_error_occurred)
break;
else if (len == SIZEOF(coll_hdr))
{
extr_collhdr = *((coll_hdr *)(ptr));
assert(hdr_lvl > '2');
new_gvn = TRUE; /* next record will contain a new gvn */
rec_count--; /* Decrement as this record does not count as a record for loading purposes */
continue;
}
rp = (rec_hdr*)(ptr);
# ifdef GTM_CRYPT
if ('5' <= hdr_lvl)
{ /* Getting index value from the extracted file. It indicates which database file this record belongs to */
GET_LONG(index, ptr);
if (-1 != index) /* Indicates that the record is encrypted. */
{
req_dec_blk_size = len - SIZEOF(int4);
inbuf = (char *)(ptr + SIZEOF(int4));
GTMCRYPT_DECODE_FAST(encr_key_handles[index], inbuf, req_dec_blk_size, NULL, crypt_status);
GC_BIN_LOAD_ERR(crypt_status);
}
rp = (rec_hdr*)(ptr + SIZEOF(int4));
}
# endif
btop = ptr + len;
cp1 = (unsigned char*)(rp + 1);
v.str.addr = (char*)cp1;
while (*cp1++)
;
v.str.len =INTCAST((char*)cp1 - v.str.addr - 1);
if (('2' >= hdr_lvl) || new_gvn)
{
if ((HASHT_GBLNAME_LEN == v.str.len) && (0 == memcmp(v.str.addr, HASHT_GBLNAME, HASHT_GBLNAME_LEN)))
continue;
bin_call_db(BIN_BIND, (INTPTR_T)gd_header, (INTPTR_T)&v.str);
max_key = gv_cur_region->max_key_size;
db_collhdr.act = gv_target->act;
db_collhdr.ver = gv_target->ver;
db_collhdr.nct = gv_target->nct;
}
GET_USHORT(rec_len, &rp->rsiz);
if (rp->cmpc != 0 || v.str.len > rec_len || mupip_error_occurred)
{
bin_call_db(ERR_COR, (INTPTR_T)rec_count, (INTPTR_T)global_key_count);
mu_gvis();
util_out_print(0, TRUE);
continue;
}
if (new_gvn)
{
global_key_count = 1;
if ((db_collhdr.act != extr_collhdr.act || db_collhdr.ver != extr_collhdr.ver
|| db_collhdr.nct != extr_collhdr.nct
|| gv_cur_region->std_null_coll != extr_std_null_coll))
{
if (extr_collhdr.act)
{
if (extr_collseq = ready_collseq((int)extr_collhdr.act))
{
if (!do_verify(extr_collseq, extr_collhdr.act, extr_collhdr.ver))
{
gtm_putmsg(VARLSTCNT(8) ERR_COLLTYPVERSION, 2, extr_collhdr.act,
extr_collhdr.ver, ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLTYPVERSION);
}
} else
{
gtm_putmsg(VARLSTCNT(7) ERR_COLLATIONUNDEF, 1, extr_collhdr.act,
ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLATIONUNDEF);
}
}
if (db_collhdr.act)
{
if (db_collseq = ready_collseq((int)db_collhdr.act))
{
if (!do_verify(db_collseq, db_collhdr.act, db_collhdr.ver))
{
gtm_putmsg(VARLSTCNT(8) ERR_COLLTYPVERSION, 2, db_collhdr.act,
db_collhdr.ver, ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLTYPVERSION);
}
} else
{
gtm_putmsg(VARLSTCNT(7) ERR_COLLATIONUNDEF, 1, db_collhdr.act,
ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLATIONUNDEF);
}
}
need_xlation = TRUE;
} else
need_xlation = FALSE;
}
new_gvn = FALSE;
for (; rp < (rec_hdr*)btop; rp = (rec_hdr*)((unsigned char *)rp + rec_len))
{
GET_USHORT(rec_len, &rp->rsiz);
if (rec_len + (unsigned char *)rp > btop)
{
bin_call_db(ERR_COR, (INTPTR_T)rec_count, (INTPTR_T)global_key_count);
mu_gvis();
util_out_print(0, TRUE);
break;
}
cp1 = (unsigned char*)(rp + 1);
cp2 = gv_currkey->base + rp->cmpc;
current = 1;
for (;;)
{
last = current;
current = *cp2++ = *cp1++;
if (0 == last && 0 == current)
break;
if (cp1 > (unsigned char *)rp + rec_len ||
cp2 > (unsigned char *)gv_currkey + gv_currkey->top)
{
bin_call_db(ERR_COR, (INTPTR_T)rec_count, (INTPTR_T)global_key_count);
mu_gvis();
util_out_print(0, TRUE);
break;
}
}
if (mupip_error_occurred)
break;
gv_currkey->end = cp2 - gv_currkey->base - 1;
if (need_xlation)
{
assert(hdr_lvl >= '3');
assert(extr_collhdr.act || db_collhdr.act || extr_collhdr.nct || db_collhdr.nct ||
extr_std_null_coll != gv_cur_region->std_null_coll);
/* gv_currkey would have been modified/translated in the earlier put */
memcpy(gv_currkey->base, cmpc_str, next_cmpc);
next_rp = (rec_hdr *)((unsigned char*)rp + rec_len);
if ((unsigned char*)next_rp < btop)
{
next_cmpc = next_rp->cmpc;
assert(next_cmpc <= gv_currkey->end);
memcpy(cmpc_str, gv_currkey->base, next_cmpc);
} else
next_cmpc = 0;
/* length of the key might change (due to nct variation),
* so get a copy of the original key from the extract */
memcpy(dup_key_str, gv_currkey->base, gv_currkey->end + 1);
gvkey_char_ptr = dup_key_str;
while (*gvkey_char_ptr++)
;
gv_currkey->prev = 0;
gv_currkey->end = gvkey_char_ptr - dup_key_str;
assert(gv_keysize <= tmp_gvkey->top);
while (*gvkey_char_ptr)
{
/* get next subscript (in GT.M internal subsc format) */
subsc_len = 0;
tmp_ptr = src_buff;
while (*gvkey_char_ptr)
*tmp_ptr++ = *gvkey_char_ptr++;
subsc_len = tmp_ptr - src_buff;
src_buff[subsc_len] = '\0';
if (extr_collseq)
{
/* undo the extract time collation */
TREF(transform) = TRUE;
save_gv_target_collseq = gv_target->collseq;
gv_target->collseq = extr_collseq;
} else
TREF(transform) = FALSE;
/* convert the subscript to string format */
end_buff = gvsub2str(src_buff, dest_buff, FALSE);
/* transform the string to the current subsc format */
TREF(transform) = TRUE;
tmp_mval.mvtype = MV_STR;
tmp_mval.str.addr = (char *)dest_buff;
tmp_mval.str.len = INTCAST(end_buff - dest_buff);
tmp_gvkey->prev = 0;
tmp_gvkey->end = 0;
if (extr_collseq)
gv_target->collseq = save_gv_target_collseq;
mval2subsc(&tmp_mval, tmp_gvkey);
/* we now have the correctly transformed subscript */
tmp_key_ptr = gv_currkey->base + gv_currkey->end;
memcpy(tmp_key_ptr, tmp_gvkey->base, tmp_gvkey->end + 1);
gv_currkey->prev = gv_currkey->end;
gv_currkey->end += tmp_gvkey->end;
gvkey_char_ptr++;
}
if ( gv_cur_region->std_null_coll != extr_std_null_coll && gv_currkey->prev)
{
if (extr_std_null_coll == 0)
{
GTM2STDNULLCOLL(gv_currkey->base, gv_currkey->end);
} else
{
STD2GTMNULLCOLL(gv_currkey->base, gv_currkey->end);
}
}
}
if (gv_currkey->end >= max_key)
{
bin_call_db(ERR_COR, (INTPTR_T)rec_count, (INTPTR_T)global_key_count);
mu_gvis();
util_out_print(0, TRUE);
continue;
}
if (max_subsc_len < (gv_currkey->end + 1))
max_subsc_len = gv_currkey->end + 1;
v.str.addr = (char*)cp1;
v.str.len =INTCAST(rec_len - (cp1 - (unsigned char *)rp));
if (max_data_len < v.str.len)
max_data_len = v.str.len;
bin_call_db(BIN_PUT, (INTPTR_T)&v, 0);
if (mupip_error_occurred)
{
if (!mupip_DB_full)
{
bin_call_db(ERR_COR, (INTPTR_T)rec_count, (INTPTR_T)global_key_count);
util_out_print(0, TRUE);
}
break;
}
key_count++;
global_key_count++;
}
}
GTMCRYPT_ONLY(
if (NULL != hash_array)
free(hash_array);
)
void bin_load(uint4 begin, uint4 end)
{
unsigned char *ptr, *cp1, *cp2, *btop, *gvkey_char_ptr, *tmp_ptr, *tmp_key_ptr;
unsigned char hdr_lvl, src_buff[MAX_KEY_SZ + 1], dest_buff[MAX_ZWR_KEY_SZ],
cmpc_str[MAX_KEY_SZ + 1], dup_key_str[MAX_KEY_SZ + 1];
unsigned char *end_buff;
unsigned short len, rec_len, next_cmpc;
int current, last, length, max_blk_siz, max_key, status;
uint4 iter, max_data_len, max_subsc_len, key_count;
ssize_t rec_count, global_key_count, subsc_len,extr_std_null_coll;
boolean_t need_xlation, new_gvn, utf8_extract;
rec_hdr *rp, *next_rp;
mval v, tmp_mval;
mstr mstr_src, mstr_dest;
collseq *extr_collseq, *db_collseq, *save_gv_target_collseq;
coll_hdr extr_collhdr, db_collhdr;
gv_key *tmp_gvkey;
char std_null_coll[BIN_HEADER_NUMSZ + 1];
error_def(ERR_GVIS);
error_def(ERR_TEXT);
error_def(ERR_LDBINFMT);
error_def(ERR_LOADCTRLY);
error_def(ERR_LOADEOF);
error_def(ERR_MUNOFINISH);
error_def(ERR_COLLTYPVERSION);
error_def(ERR_COLLATIONUNDEF);
error_def(ERR_OLDBINEXTRACT);
error_def(ERR_LOADINVCHSET);
tmp_gvkey = (gv_key *)malloc(sizeof(gv_key) + MAX_KEY_SZ - 1);
assert(4 == sizeof(coll_hdr));
gvinit();
v.mvtype = MV_STR;
len = mu_bin_get((char **)&ptr);
hdr_lvl = EXTR_HEADER_LEVEL(ptr);
if (!((hdr_lvl == '4' && len == BIN_HEADER_SZ) || (hdr_lvl < '4' && len == V3_BIN_HEADER_SZ)))
{
rts_error(VARLSTCNT(1) ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
/* assert the assumption that the level can be represented in a single character */
assert(' ' == *(ptr + sizeof(BIN_HEADER_LABEL) - 3));
if (0 != memcmp(ptr, BIN_HEADER_LABEL, sizeof(BIN_HEADER_LABEL) - 2) || hdr_lvl < '2' || *(BIN_HEADER_VERSION) < hdr_lvl)
{ /* ignore the level check */
rts_error(VARLSTCNT(1) ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
/* check if extract was generated in UTF-8 mode */
utf8_extract = (0 == MEMCMP_LIT(&ptr[len - BIN_HEADER_LABELSZ], UTF8_NAME)) ? TRUE : FALSE;
if ((utf8_extract && !gtm_utf8_mode) || (!utf8_extract && gtm_utf8_mode))
{ /* extract CHSET doesn't match $ZCHSET */
if (utf8_extract)
rts_error(VARLSTCNT(4) ERR_LOADINVCHSET, 2, LEN_AND_LIT("UTF-8"));
else
rts_error(VARLSTCNT(4) ERR_LOADINVCHSET, 2, LEN_AND_LIT("M"));
mupip_exit(ERR_LDBINFMT);
}
util_out_print("Label = !AD\n", TRUE, len, ptr);
new_gvn = FALSE;
if (hdr_lvl > '3')
{
memcpy(std_null_coll, ptr + BIN_HEADER_NULLCOLLOFFSET, BIN_HEADER_NUMSZ);
std_null_coll[BIN_HEADER_NUMSZ] = '\0';
extr_std_null_coll = STRTOUL(std_null_coll, NULL, 10);
if (0 != extr_std_null_coll && 1!= extr_std_null_coll)
{
rts_error(VARLSTCNT(5) ERR_TEXT, 2, RTS_ERROR_TEXT("Corrupted null collation field in header"),
ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
} else
extr_std_null_coll = 0;
if (hdr_lvl > '2')
{
len = mu_bin_get((char **)&ptr);
if (sizeof(coll_hdr) != len)
{
rts_error(VARLSTCNT(5) ERR_TEXT, 2, RTS_ERROR_TEXT("Corrupt collation header"), ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
extr_collhdr = *((coll_hdr *)(ptr));
new_gvn = TRUE;
} else
gtm_putmsg(VARLSTCNT(3) ERR_OLDBINEXTRACT, 1, hdr_lvl - '0');
if (begin < 2)
begin = 2;
for (iter = 2; iter < begin; iter++)
{
if (!(len = mu_bin_get((char **)&ptr)))
{
gtm_putmsg(VARLSTCNT(3) ERR_LOADEOF, 1, begin);
util_out_print("Error reading record number: !UL\n", TRUE, iter);
mupip_error_occurred = TRUE;
return;
} else if (len == sizeof(coll_hdr))
{
extr_collhdr = *((coll_hdr *)(ptr));
assert(hdr_lvl > '2');
iter--;
}
}
assert(iter == begin);
util_out_print("Beginning LOAD at record number: !UL\n", TRUE, begin);
max_data_len = 0;
max_subsc_len = 0;
key_count = 0;
rec_count = begin - 1;
extr_collseq = db_collseq = NULL;
need_xlation = FALSE;
for (; !mupip_DB_full ;)
{
if (++rec_count > end)
break;
next_cmpc = 0;
mupip_error_occurred = FALSE;
if (mu_ctrly_occurred)
break;
if (mu_ctrlc_occurred)
{
util_out_print("!AD:!_ Key cnt: !UL max subsc len: !UL max data len: !UL", TRUE,
LEN_AND_LIT(gt_lit), key_count, max_subsc_len, max_data_len);
util_out_print("Last LOAD record number: !UL", TRUE, key_count ? (rec_count - 1) : 0);
mu_gvis();
util_out_print(0, TRUE);
mu_ctrlc_occurred = FALSE;
}
/* reset the stringpool for every record in order to avoid garbage collection */
stringpool.free = stringpool.base;
if (!(len = mu_bin_get((char **)&ptr)) || mupip_error_occurred)
break;
else if (len == sizeof(coll_hdr))
{
extr_collhdr = *((coll_hdr *)(ptr));
assert(hdr_lvl > '2');
new_gvn = TRUE; /* next record will contain a new gvn */
rec_count--; /* Decrement as this record does not count as a record for loading purposes */
continue;
}
global_key_count = 1;
rp = (rec_hdr*)ptr;
btop = ptr + len;
cp1 = (unsigned char*)(rp + 1);
v.str.addr = (char*)cp1;
while (*cp1++) ;
v.str.len =INTCAST((char*)cp1 - v.str.addr - 1);
if (hdr_lvl <= '2' || new_gvn)
{
bin_call_db(BIN_BIND, (INTPTR_T)gd_header, (INTPTR_T)&v.str);
max_key = gv_cur_region->max_key_size;
db_collhdr.act = gv_target->act;
db_collhdr.ver = gv_target->ver;
db_collhdr.nct = gv_target->nct;
}
GET_SHORT(rec_len, &rp->rsiz);
if (rp->cmpc != 0 || v.str.len > rec_len || mupip_error_occurred)
{
bin_call_db(ERR_COR, rec_count, global_key_count);
mu_gvis();
util_out_print(0, TRUE);
continue;
}
if (new_gvn)
{
if ((db_collhdr.act != extr_collhdr.act || db_collhdr.ver != extr_collhdr.ver
|| db_collhdr.nct != extr_collhdr.nct
|| gv_cur_region->std_null_coll != extr_std_null_coll))
{
if (extr_collhdr.act)
{
if (extr_collseq = ready_collseq((int)extr_collhdr.act))
{
if (!do_verify(extr_collseq, extr_collhdr.act, extr_collhdr.ver))
{
gtm_putmsg(VARLSTCNT(8) ERR_COLLTYPVERSION, 2, extr_collhdr.act,
extr_collhdr.ver, ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLTYPVERSION);
}
} else
{
gtm_putmsg(VARLSTCNT(7) ERR_COLLATIONUNDEF, 1, extr_collhdr.act,
ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLATIONUNDEF);
}
}
if (db_collhdr.act)
{
if (db_collseq = ready_collseq((int)db_collhdr.act))
{
if (!do_verify(db_collseq, db_collhdr.act, db_collhdr.ver))
{
gtm_putmsg(VARLSTCNT(8) ERR_COLLTYPVERSION, 2, db_collhdr.act,
db_collhdr.ver, ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLTYPVERSION);
}
} else
{
gtm_putmsg(VARLSTCNT(7) ERR_COLLATIONUNDEF, 1, db_collhdr.act,
ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLATIONUNDEF);
}
}
need_xlation = TRUE;
} else
need_xlation = FALSE;
}
new_gvn = FALSE;
for (; rp < (rec_hdr*)btop; rp = (rec_hdr*)((unsigned char *)rp + rec_len))
{
GET_SHORT(rec_len, &rp->rsiz);
if (rec_len + (unsigned char *)rp > btop)
{
bin_call_db(ERR_COR, rec_count, global_key_count);
mu_gvis();
util_out_print(0, TRUE);
break;
}
cp1 = (unsigned char*)(rp + 1);
cp2 = gv_currkey->base + rp->cmpc;
current = 1;
for (;;)
{
last = current;
current = *cp2++ = *cp1++;
if (0 == last && 0 == current)
break;
if (cp1 > (unsigned char *) rp + rec_len ||
cp2 > (unsigned char *) gv_currkey + gv_currkey->top)
{
bin_call_db(ERR_COR, rec_count, global_key_count);
mu_gvis();
util_out_print(0, TRUE);
break;
}
}
if (mupip_error_occurred)
break;
gv_currkey->end = cp2 - gv_currkey->base - 1;
if (need_xlation)
{
assert(hdr_lvl >= '3');
assert(extr_collhdr.act || db_collhdr.act || extr_collhdr.nct || db_collhdr.nct ||
extr_std_null_coll != gv_cur_region->std_null_coll);
/* gv_currkey would have been modified/translated in the earlier put */
memcpy(gv_currkey->base, cmpc_str, next_cmpc);
next_rp = (rec_hdr *)((unsigned char*)rp + rec_len);
if ((unsigned char*)next_rp < btop)
{
next_cmpc = next_rp->cmpc;
assert(next_cmpc <= gv_currkey->end);
memcpy(cmpc_str, gv_currkey->base, next_cmpc);
} else
next_cmpc = 0;
/* length of the key might change (due to nct variation),
* so get a copy of the original key from the extract */
memcpy(dup_key_str, gv_currkey->base, gv_currkey->end + 1);
gvkey_char_ptr = dup_key_str;
while (*gvkey_char_ptr++) ;
gv_currkey->prev = 0;
gv_currkey->end = gvkey_char_ptr - dup_key_str;
tmp_gvkey->top = gv_keysize;
while (*gvkey_char_ptr)
{
/* get next subscript (in GT.M internal subsc format) */
subsc_len = 0;
tmp_ptr = src_buff;
while (*gvkey_char_ptr)
*tmp_ptr++ = *gvkey_char_ptr++;
subsc_len = tmp_ptr - src_buff;
src_buff[subsc_len] = '\0';
if (extr_collseq)
{
/* undo the extract time collation */
transform = TRUE;
save_gv_target_collseq = gv_target->collseq;
gv_target->collseq = extr_collseq;
} else
transform = FALSE;
/* convert the subscript to string format */
end_buff = gvsub2str(src_buff, dest_buff, FALSE);
/* transform the string to the current subsc format */
transform = TRUE;
tmp_mval.mvtype = MV_STR;
tmp_mval.str.addr = (char *)dest_buff;
tmp_mval.str.len = INTCAST(end_buff - dest_buff);
tmp_gvkey->prev = 0;
tmp_gvkey->end = 0;
if (extr_collseq)
gv_target->collseq = save_gv_target_collseq;
mval2subsc(&tmp_mval, tmp_gvkey);
/* we now have the correctly transformed subscript */
tmp_key_ptr = gv_currkey->base + gv_currkey->end;
memcpy(tmp_key_ptr, tmp_gvkey->base, tmp_gvkey->end + 1);
gv_currkey->prev = gv_currkey->end;
gv_currkey->end += tmp_gvkey->end;
gvkey_char_ptr++;
}
if ( gv_cur_region->std_null_coll != extr_std_null_coll && gv_currkey->prev)
{
if (extr_std_null_coll == 0)
{
GTM2STDNULLCOLL(gv_currkey->base, gv_currkey->end);
} else
{
STD2GTMNULLCOLL(gv_currkey->base, gv_currkey->end);
}
}
}
if (gv_currkey->end >= max_key)
{
bin_call_db(ERR_COR, rec_count, global_key_count);
mu_gvis();
util_out_print(0, TRUE);
continue;
}
if (max_subsc_len < (gv_currkey->end + 1))
max_subsc_len = gv_currkey->end + 1;
v.str.addr = (char*)cp1;
v.str.len =INTCAST(rec_len - (cp1 - (unsigned char *)rp) );
if (max_data_len < v.str.len)
max_data_len = v.str.len;
bin_call_db(BIN_PUT, (INTPTR_T)&v, 0);
if (mupip_error_occurred)
{
if (!mupip_DB_full)
{
bin_call_db(ERR_COR, rec_count, global_key_count);
util_out_print(0, TRUE);
}
break;
}
key_count++;
global_key_count++;
}
}
free(tmp_gvkey);
mu_load_close();
util_out_print("LOAD TOTAL!_!_Key Cnt: !UL Max Subsc Len: !UL Max Data Len: !UL", TRUE, key_count, max_subsc_len,
max_data_len);
util_out_print("Last LOAD record number: !UL\n", TRUE, key_count ? (rec_count - 1) : 0);
if (mu_ctrly_occurred)
{
gtm_putmsg(VARLSTCNT(1) ERR_LOADCTRLY);
mupip_exit(ERR_MUNOFINISH);
}
}
void bin_load(uint4 begin, uint4 end)
{
unsigned char *ptr, *cp1, *cp2, *btop, *gvkey_char_ptr, *tmp_ptr, *tmp_key_ptr, *c, *ctop, *ptr_base;
unsigned char hdr_lvl, src_buff[MAX_KEY_SZ + 1], dest_buff[MAX_ZWR_KEY_SZ],
cmpc_str[MAX_KEY_SZ + 1], dup_key_str[MAX_KEY_SZ + 1], sn_key_str[MAX_KEY_SZ + 1], *sn_key_str_end;
unsigned char *end_buff;
unsigned short rec_len, next_cmpc, numsubs;
int len;
int current, last, length, max_blk_siz, max_key, status;
int tmp_cmpc, sn_chunk_number, expected_sn_chunk_number = 0, sn_hold_buff_pos, sn_hold_buff_size;
uint4 iter, max_data_len, max_subsc_len, key_count, gblsize;
ssize_t rec_count, global_key_count, subsc_len,extr_std_null_coll, last_sn_error_offset=0,
file_offset_base=0, file_offset=0;
boolean_t need_xlation, new_gvn, utf8_extract;
boolean_t is_hidden_subscript, ok_to_put = TRUE, putting_a_sn = FALSE, sn_incmp_gbl_already_killed = FALSE;
rec_hdr *rp, *next_rp;
mval v, tmp_mval;
mstr mstr_src, mstr_dest;
collseq *extr_collseq, *db_collseq, *save_gv_target_collseq;
coll_hdr extr_collhdr, db_collhdr;
gv_key *tmp_gvkey = NULL; /* null-initialize at start, will be malloced later */
gv_key *sn_gvkey = NULL; /* null-initialize at start, will be malloced later */
gv_key *sn_savekey = NULL; /* null-initialize at start, will be malloced later */
char std_null_coll[BIN_HEADER_NUMSZ + 1], *sn_hold_buff = NULL, *sn_hold_buff_temp = NULL;
# ifdef GTM_CRYPT
gtmcrypt_key_t *encr_key_handles;
char *inbuf;
int4 index;
int req_dec_blk_size, init_status, crypt_status;
muext_hash_hdr_ptr_t hash_array = NULL;
# endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(4 == SIZEOF(coll_hdr));
gvinit();
v.mvtype = MV_STR;
len = file_input_bin_get((char **)&ptr, &file_offset_base, (char **)&ptr_base);
hdr_lvl = EXTR_HEADER_LEVEL(ptr);
if (!(((('4' == hdr_lvl) || ('5' == hdr_lvl)) && (V5_BIN_HEADER_SZ == len)) ||
(('6' == hdr_lvl) && (BIN_HEADER_SZ == len)) ||
(('7' == hdr_lvl) && (BIN_HEADER_SZ == len)) ||
(('4' > hdr_lvl) && (V3_BIN_HEADER_SZ == len))))
{
rts_error(VARLSTCNT(1) ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
/* expecting the level in a single character */
assert(' ' == *(ptr + SIZEOF(BIN_HEADER_LABEL) - 3));
if (0 != memcmp(ptr, BIN_HEADER_LABEL, SIZEOF(BIN_HEADER_LABEL) - 2) || ('2' > hdr_lvl) ||
*(BIN_HEADER_VERSION_ENCR) < hdr_lvl)
{ /* ignore the level check */
rts_error(VARLSTCNT(1) ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
/* check if extract was generated in UTF-8 mode */
utf8_extract = (0 == MEMCMP_LIT(&ptr[len - BIN_HEADER_LABELSZ], UTF8_NAME)) ? TRUE : FALSE;
if ((utf8_extract && !gtm_utf8_mode) || (!utf8_extract && gtm_utf8_mode))
{ /* extract CHSET doesn't match $ZCHSET */
if (utf8_extract)
rts_error(VARLSTCNT(4) ERR_LOADINVCHSET, 2, LEN_AND_LIT("UTF-8"));
else
rts_error(VARLSTCNT(4) ERR_LOADINVCHSET, 2, LEN_AND_LIT("M"));
mupip_exit(ERR_LDBINFMT);
}
if ('4' >= hdr_lvl)
{ /* Binary extracts in V50000-to-V52000 (label=4) and pre-V50000 (label=3) could have a '\0' byte (NULL byte)
* in the middle of the string. Replace it with ' ' (space) like it would be in V52000 binary extracts and above.
*/
for (c = ptr, ctop = c + len; c < ctop; c++)
{
if ('\0' == *c)
*c = ' ';
}
}
util_out_print("Label = !AD\n", TRUE, len, ptr);
new_gvn = FALSE;
if (hdr_lvl > '3')
{
if (hdr_lvl > '5')
{
memcpy(std_null_coll, ptr + BIN_HEADER_NULLCOLLOFFSET, BIN_HEADER_NUMSZ);
std_null_coll[BIN_HEADER_NUMSZ] = '\0';
}
else
{
memcpy(std_null_coll, ptr + V5_BIN_HEADER_NULLCOLLOFFSET, V5_BIN_HEADER_NUMSZ);
std_null_coll[V5_BIN_HEADER_NUMSZ] = '\0';
}
extr_std_null_coll = STRTOUL(std_null_coll, NULL, 10);
if (0 != extr_std_null_coll && 1!= extr_std_null_coll)
{
rts_error(VARLSTCNT(5) ERR_TEXT, 2, RTS_ERROR_TEXT("Corrupted null collation field in header"),
ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
} else
extr_std_null_coll = 0;
# ifdef GTM_CRYPT
if ('7' <= hdr_lvl)
{
int i, num_indexes;
len = file_input_bin_get((char **)&ptr, &file_offset_base, (char **)&ptr_base);
hash_array = (muext_hash_hdr *)malloc(len);
/* store hashes of all the files used during extract into muext_hash_hdr structure */
memcpy((char *)hash_array, ptr, len);
num_indexes = len / GTMCRYPT_HASH_LEN;
encr_key_handles = (gtmcrypt_key_t *)malloc(SIZEOF(gtmcrypt_key_t) * num_indexes);
INIT_PROC_ENCRYPTION(crypt_status);
GC_BIN_LOAD_ERR(crypt_status);
for (index = 0; index < num_indexes; index++)
{
if (0 == memcmp(hash_array[index].gtmcrypt_hash, EMPTY_GTMCRYPT_HASH, GTMCRYPT_HASH_LEN))
continue;
GTMCRYPT_GETKEY(hash_array[index].gtmcrypt_hash, encr_key_handles[index], crypt_status);
GC_BIN_LOAD_ERR(crypt_status);
}
}
# endif
if ('2' < hdr_lvl)
{
len = file_input_bin_get((char **)&ptr, &file_offset_base, (char **)&ptr_base);
if (SIZEOF(coll_hdr) != len)
{
rts_error(VARLSTCNT(5) ERR_TEXT, 2, RTS_ERROR_TEXT("Corrupt collation header"), ERR_LDBINFMT);
mupip_exit(ERR_LDBINFMT);
}
extr_collhdr = *((coll_hdr *)(ptr));
new_gvn = TRUE;
} else
gtm_putmsg(VARLSTCNT(3) ERR_OLDBINEXTRACT, 1, hdr_lvl - '0');
if (begin < 2)
begin = 2;
for (iter = 2; iter < begin; iter++)
{
if (!(len = file_input_bin_get((char **)&ptr, &file_offset_base, (char **)&ptr_base)))
{
gtm_putmsg(VARLSTCNT(3) ERR_LOADEOF, 1, begin);
util_out_print("Error reading record number: !UL\n", TRUE, iter);
mupip_error_occurred = TRUE;
return;
} else if (len == SIZEOF(coll_hdr))
{
extr_collhdr = *((coll_hdr *)(ptr));
assert(hdr_lvl > '2');
iter--;
}
}
assert(iter == begin);
util_out_print("Beginning LOAD at record number: !UL\n", TRUE, begin);
max_data_len = 0;
max_subsc_len = 0;
global_key_count = key_count = 0;
rec_count = begin - 1;
extr_collseq = db_collseq = NULL;
need_xlation = FALSE;
assert(NULL == tmp_gvkey); /* GVKEY_INIT macro relies on this */
GVKEY_INIT(tmp_gvkey, DBKEYSIZE(MAX_KEY_SZ)); /* tmp_gvkey will point to malloced memory after this */
assert(NULL == sn_gvkey); /* GVKEY_INIT macro relies on this */
GVKEY_INIT(sn_gvkey, DBKEYSIZE(MAX_KEY_SZ)); /* sn_gvkey will point to malloced memory after this */
assert(NULL == sn_savekey); /* GVKEY_INIT macro relies on this */
GVKEY_INIT(sn_savekey, DBKEYSIZE(MAX_KEY_SZ)); /* sn_gvkey will point to malloced memory after this */
for (; !mupip_DB_full ;)
{
if (++rec_count > end)
break;
next_cmpc = 0;
mupip_error_occurred = FALSE;
if (mu_ctrly_occurred)
break;
if (mu_ctrlc_occurred)
{
util_out_print("!AD:!_ Key cnt: !UL max subsc len: !UL max data len: !UL", TRUE,
LEN_AND_LIT(gt_lit), key_count, max_subsc_len, max_data_len);
util_out_print("Last LOAD record number: !UL", TRUE, key_count ? (rec_count - 1) : 0);
mu_gvis();
util_out_print(0, TRUE);
mu_ctrlc_occurred = FALSE;
}
if (!(len = file_input_bin_get((char **)&ptr, &file_offset_base, (char **)&ptr_base)) || mupip_error_occurred)
break;
else if (len == SIZEOF(coll_hdr))
{
extr_collhdr = *((coll_hdr *)(ptr));
assert(hdr_lvl > '2');
new_gvn = TRUE; /* next record will contain a new gvn */
rec_count--; /* Decrement as this record does not count as a record for loading purposes */
continue;
}
rp = (rec_hdr*)(ptr);
# ifdef GTM_CRYPT
if ('7' <= hdr_lvl)
{ /* Getting index value from the extracted file. It indicates which database file this record belongs to */
GET_LONG(index, ptr);
if (-1 != index) /* Indicates that the record is encrypted. */
{
req_dec_blk_size = len - SIZEOF(int4);
inbuf = (char *)(ptr + SIZEOF(int4));
GTMCRYPT_DECODE_FAST(encr_key_handles[index], inbuf, req_dec_blk_size, NULL, crypt_status);
GC_BIN_LOAD_ERR(crypt_status);
}
rp = (rec_hdr*)(ptr + SIZEOF(int4));
}
# endif
btop = ptr + len;
cp1 = (unsigned char*)(rp + 1);
v.str.addr = (char*)cp1;
while (*cp1++)
;
v.str.len =INTCAST((char*)cp1 - v.str.addr - 1);
if (('2' >= hdr_lvl) || new_gvn)
{
if ((HASHT_GBLNAME_LEN == v.str.len) && (0 == memcmp(v.str.addr, HASHT_GBLNAME, HASHT_GBLNAME_LEN)))
continue;
bin_call_db(BIN_BIND, (INTPTR_T)gd_header, (INTPTR_T)&v.str);
max_key = gv_cur_region->max_key_size;
db_collhdr.act = gv_target->act;
db_collhdr.ver = gv_target->ver;
db_collhdr.nct = gv_target->nct;
}
GET_USHORT(rec_len, &rp->rsiz);
if (EVAL_CMPC(rp) != 0 || v.str.len > rec_len || mupip_error_occurred)
{
bin_call_db(ERR_COR, (INTPTR_T)rec_count, (INTPTR_T)global_key_count);
mu_gvis();
DISPLAY_FILE_OFFSET_OF_RECORD_AND_REST_OF_BLOCK;
continue;
}
if (new_gvn)
{
global_key_count = 1;
if ((db_collhdr.act != extr_collhdr.act || db_collhdr.ver != extr_collhdr.ver
|| db_collhdr.nct != extr_collhdr.nct
|| gv_cur_region->std_null_coll != extr_std_null_coll))
{
if (extr_collhdr.act)
{
if (extr_collseq = ready_collseq((int)extr_collhdr.act))
{
if (!do_verify(extr_collseq, extr_collhdr.act, extr_collhdr.ver))
{
gtm_putmsg(VARLSTCNT(8) ERR_COLLTYPVERSION, 2, extr_collhdr.act,
extr_collhdr.ver, ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLTYPVERSION);
}
} else
{
gtm_putmsg(VARLSTCNT(7) ERR_COLLATIONUNDEF, 1, extr_collhdr.act,
ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLATIONUNDEF);
}
}
if (db_collhdr.act)
{
if (db_collseq = ready_collseq((int)db_collhdr.act))
{
if (!do_verify(db_collseq, db_collhdr.act, db_collhdr.ver))
{
gtm_putmsg(VARLSTCNT(8) ERR_COLLTYPVERSION, 2, db_collhdr.act,
db_collhdr.ver, ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLTYPVERSION);
}
} else
{
gtm_putmsg(VARLSTCNT(7) ERR_COLLATIONUNDEF, 1, db_collhdr.act,
ERR_GVIS, 2, gv_altkey->end - 1, gv_altkey->base);
mupip_exit(ERR_COLLATIONUNDEF);
}
}
need_xlation = TRUE;
} else
need_xlation = FALSE;
}
new_gvn = FALSE;
for (; rp < (rec_hdr*)btop; rp = (rec_hdr*)((unsigned char *)rp + rec_len))
{
GET_USHORT(rec_len, &rp->rsiz);
if (rec_len + (unsigned char *)rp > btop)
{
bin_call_db(ERR_COR, (INTPTR_T)rec_count, (INTPTR_T)global_key_count);
mu_gvis();
DISPLAY_FILE_OFFSET_OF_RECORD_AND_REST_OF_BLOCK;
break;
}
cp1 = (unsigned char*)(rp + 1);
cp2 = gv_currkey->base + EVAL_CMPC(rp);
current = 1;
for (;;)
{
last = current;
current = *cp2++ = *cp1++;
if (0 == last && 0 == current)
break;
if (cp1 > (unsigned char *)rp + rec_len ||
cp2 > (unsigned char *)gv_currkey + gv_currkey->top)
{
gv_currkey->end = cp2 - gv_currkey->base - 1;
gv_currkey->base[gv_currkey->end] = 0;
gv_currkey->base[gv_currkey->end - 1] = 0;
bin_call_db(ERR_COR, (INTPTR_T)rec_count, (INTPTR_T)global_key_count);
mu_gvis();
DISPLAY_FILE_OFFSET_OF_RECORD_AND_REST_OF_BLOCK;
break;
}
}
if (mupip_error_occurred)
break;
gv_currkey->end = cp2 - gv_currkey->base - 1;
if (need_xlation)
{
assert(hdr_lvl >= '3');
assert(extr_collhdr.act || db_collhdr.act || extr_collhdr.nct || db_collhdr.nct ||
extr_std_null_coll != gv_cur_region->std_null_coll);
/* gv_currkey would have been modified/translated in the earlier put */
memcpy(gv_currkey->base, cmpc_str, next_cmpc);
next_rp = (rec_hdr *)((unsigned char*)rp + rec_len);
if ((unsigned char*)next_rp < btop)
{
next_cmpc = EVAL_CMPC(next_rp);
assert(next_cmpc <= gv_currkey->end);
memcpy(cmpc_str, gv_currkey->base, next_cmpc);
} else
next_cmpc = 0;
/* length of the key might change (due to nct variation),
* so get a copy of the original key from the extract */
memcpy(dup_key_str, gv_currkey->base, gv_currkey->end + 1);
gvkey_char_ptr = dup_key_str;
while (*gvkey_char_ptr++)
;
gv_currkey->prev = 0;
gv_currkey->end = gvkey_char_ptr - dup_key_str;
assert(gv_keysize <= tmp_gvkey->top);
while (*gvkey_char_ptr)
{
/* get next subscript (in GT.M internal subsc format) */
subsc_len = 0;
tmp_ptr = src_buff;
while (*gvkey_char_ptr)
*tmp_ptr++ = *gvkey_char_ptr++;
subsc_len = tmp_ptr - src_buff;
src_buff[subsc_len] = '\0';
if (extr_collseq)
{
/* undo the extract time collation */
TREF(transform) = TRUE;
save_gv_target_collseq = gv_target->collseq;
gv_target->collseq = extr_collseq;
} else
TREF(transform) = FALSE;
/* convert the subscript to string format */
end_buff = gvsub2str(src_buff, dest_buff, FALSE);
/* transform the string to the current subsc format */
TREF(transform) = TRUE;
tmp_mval.mvtype = MV_STR;
tmp_mval.str.addr = (char *)dest_buff;
tmp_mval.str.len = INTCAST(end_buff - dest_buff);
tmp_gvkey->prev = 0;
tmp_gvkey->end = 0;
if (extr_collseq)
gv_target->collseq = save_gv_target_collseq;
mval2subsc(&tmp_mval, tmp_gvkey);
/* we now have the correctly transformed subscript */
tmp_key_ptr = gv_currkey->base + gv_currkey->end;
memcpy(tmp_key_ptr, tmp_gvkey->base, tmp_gvkey->end + 1);
gv_currkey->prev = gv_currkey->end;
gv_currkey->end += tmp_gvkey->end;
gvkey_char_ptr++;
}
if ( gv_cur_region->std_null_coll != extr_std_null_coll && gv_currkey->prev)
{
if (extr_std_null_coll == 0)
{
GTM2STDNULLCOLL(gv_currkey->base, gv_currkey->end);
} else
{
STD2GTMNULLCOLL(gv_currkey->base, gv_currkey->end);
}
}
}
if (gv_currkey->end >= max_key)
{
bin_call_db(ERR_COR, (INTPTR_T)rec_count, (INTPTR_T)global_key_count);
mu_gvis();
DISPLAY_FILE_OFFSET_OF_RECORD_AND_REST_OF_BLOCK;
continue;
}
/*
* Spanning node-related variables and their usage:
*
* expected_sn_chunk_number: 0 - looking for spanning nodes (regular nodes are OK, too)
* !0 - number of the next chunk needed (implies we are building
* a spanning node's value)
*
* While building a spanning node's value:
* numsubs: the number of chunks needed to build the spanning node's value
* gblsize: the expected size of the completed value
* sn_chunk_number: The chunk number of the chunk from the current record from the extract
*
* Managing the value
* sn_hold_buff: buffer used to accumulate the spanning node's value
* sn_hold_buff_size: Allocated size of buffer
* sn_hold_buff_pos: amount of the buffer used; where to place the next chunk
* sn_hold_buff_temp: used when we have to increase the size of the buffer
*
* Controlling the placing of the key,value in the database:
* ok_to_put: means we are ready to place the key,value in the database, i.e., we have the full value
* (either of the spanning node or a regular node).
* putting_a_sn: we are placing a spanning node in the database, i.e, use the key from sn_gvkey and
* the value from sn_hold_buff.
*/
CHECK_HIDDEN_SUBSCRIPT(gv_currkey,is_hidden_subscript);
if (!is_hidden_subscript && (max_subsc_len < (gv_currkey->end + 1)))
max_subsc_len = gv_currkey->end + 1;
v.str.addr = (char*)cp1;
v.str.len =INTCAST(rec_len - (cp1 - (unsigned char *)rp));
if (expected_sn_chunk_number && !is_hidden_subscript)
{ /* we were expecting a chunk of an spanning node and we did not get one */
DISPLAY_INCMP_SN_MSG;
util_out_print("!_!_Expected chunk number : !UL but found a non-spanning node", TRUE,
expected_sn_chunk_number + 1);
if (sn_hold_buff_pos)
DISPLAY_PARTIAL_SN_HOLD_BUFF;
KILL_INCMP_SN_IF_NEEDED;
sn_hold_buff_pos = 0;
expected_sn_chunk_number = 0;
ok_to_put = TRUE;
putting_a_sn = FALSE;
numsubs = 0;
}
if (is_hidden_subscript)
{ /* it's a chunk and we were expecting one */
sn_chunk_number = SPAN_GVSUBS2INT((span_subs *) &(gv_currkey->base[gv_currkey->end - 4]));
if (!expected_sn_chunk_number && is_hidden_subscript && sn_chunk_number)
{ /* we not expecting a payload chunk (as opposed to a control record) but we got one */
DISPLAY_INCMP_SN_MSG;
util_out_print("!_!_Not expecting a spanning node chunk but found chunk : !UL", TRUE,
sn_chunk_number + 1);
if (v.str.len)
DISPLAY_VALUE("!_!_Errant Chunk :");
continue;
}
if (0 == sn_chunk_number)
{ /* first spanning node chunk, get ctrl info */
if (0 != expected_sn_chunk_number)
{
DISPLAY_INCMP_SN_MSG;
util_out_print("!_!_Expected chunk number : !UL but found chunk number : !UL", TRUE,
expected_sn_chunk_number + 1, sn_chunk_number + 1);
if (sn_hold_buff_pos)
DISPLAY_PARTIAL_SN_HOLD_BUFF;
KILL_INCMP_SN_IF_NEEDED;
}
/* start building a new spanning node */
sn_gvkey->end = gv_currkey->end - (SPAN_SUBS_LEN + 1);
memcpy(sn_gvkey->base, gv_currkey->base, sn_gvkey->end);
sn_gvkey->base[sn_gvkey->end] = 0;
sn_gvkey->prev = gv_currkey->prev;
sn_gvkey->top = gv_currkey->top;
GET_NSBCTRL(v.str.addr, numsubs, gblsize);
/* look for first payload chunk */
expected_sn_chunk_number = 1;
sn_hold_buff_pos = 0;
ok_to_put = FALSE;
sn_incmp_gbl_already_killed = FALSE;
} else
{ /* we only need to compare the key before the hidden subscripts */
if ((expected_sn_chunk_number == sn_chunk_number)
&& (sn_gvkey->end == gv_currkey->end - (SPAN_SUBS_LEN + 1))
&& !memcmp(sn_gvkey->base,gv_currkey->base, sn_gvkey->end)
&& ((sn_hold_buff_pos + v.str.len) <= gblsize))
{
if (NULL == sn_hold_buff)
{
sn_hold_buff_size = DEFAULT_SN_HOLD_BUFF_SIZE;
sn_hold_buff = (char *)malloc(DEFAULT_SN_HOLD_BUFF_SIZE);
}
if ((sn_hold_buff_pos + v.str.len) > sn_hold_buff_size)
{
sn_hold_buff_size = sn_hold_buff_size * 2;
sn_hold_buff_temp = (char *)malloc(sn_hold_buff_size);
memcpy(sn_hold_buff_temp, sn_hold_buff, sn_hold_buff_pos);
free (sn_hold_buff);
sn_hold_buff = sn_hold_buff_temp;
}
memcpy(sn_hold_buff + sn_hold_buff_pos, v.str.addr, v.str.len);
sn_hold_buff_pos += v.str.len;
if (expected_sn_chunk_number == numsubs)
{
if (sn_hold_buff_pos != gblsize)
{ /* we don't have the expected size even though */
/* we have all the expected chunks. */
DISPLAY_INCMP_SN_MSG;
util_out_print("!_!_Expected size : !UL actual size : !UL", TRUE,
gblsize, sn_hold_buff_pos);
if (sn_hold_buff_pos)
DISPLAY_PARTIAL_SN_HOLD_BUFF;
KILL_INCMP_SN_IF_NEEDED;
expected_sn_chunk_number = 0;
ok_to_put = FALSE;
sn_hold_buff_pos = 0;
}
else
{
expected_sn_chunk_number = 0;
ok_to_put = TRUE;
putting_a_sn = TRUE;
}
}else
expected_sn_chunk_number++;
}else
{
DISPLAY_INCMP_SN_MSG;
if ((sn_hold_buff_pos + v.str.len) <= gblsize)
util_out_print("!_!_Expected chunk number : !UL but found chunk number : !UL", /*BYPASSOK*/
TRUE, expected_sn_chunk_number + 1, sn_chunk_number + 1);
else
util_out_print("!_!_Global value too large: expected size : !UL actual size : !UL chunk number : !UL", TRUE, /*BYPASSOK*/
gblsize, sn_hold_buff_pos + v.str.len, sn_chunk_number + 1);
if (sn_hold_buff_pos)
DISPLAY_PARTIAL_SN_HOLD_BUFF;
if (v.str.len)
DISPLAY_VALUE("!_!_Errant Chunk :");
KILL_INCMP_SN_IF_NEEDED;
sn_hold_buff_pos = 0;
expected_sn_chunk_number = 0;
}
}
} else
ok_to_put = TRUE;
if (ok_to_put)
{
if (putting_a_sn)
{
gv_currkey->base[gv_currkey->end - (SPAN_SUBS_LEN + 1)] = 0;
gv_currkey->end -= (SPAN_SUBS_LEN + 1);
v.str.addr = sn_hold_buff;
v.str.len = sn_hold_buff_pos;
}
if (max_data_len < v.str.len)
max_data_len = v.str.len;
bin_call_db(BIN_PUT, (INTPTR_T)&v, 0);
if (mupip_error_occurred)
{
if (!mupip_DB_full)
{
bin_call_db(ERR_COR, (INTPTR_T)rec_count, (INTPTR_T)global_key_count);
file_offset = file_offset_base + ((unsigned char *)rp - ptr_base);
util_out_print("!_!_at File offset : [0x!XL]", TRUE, file_offset);
DISPLAY_CURRKEY;
DISPLAY_VALUE("!_!_Value :");
}
break;
}
if (putting_a_sn)
putting_a_sn = FALSE;
else
{
key_count++;
global_key_count++;
}
}
}
}
GTMCRYPT_ONLY(
if (NULL != hash_array)
free(hash_array);
)
void op_merge(void)
{
boolean_t found, check_for_null_subs, is_base_var;
lv_val *dst_lv;
mval *mkey, *value, *subsc;
int org_glvn1_keysz, org_glvn2_keysz, delta2, dollardata_src, dollardata_dst, sbs_depth;
unsigned char *ptr, *ptr2;
unsigned char buff[MAX_ZWR_KEY_SZ];
unsigned char nullcoll_src, nullcoll_dst;
zshow_out output;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(MAX_STRLEN >= MAX_ZWR_KEY_SZ);
assert ((merge_args == (MARG1_LCL | MARG2_LCL)) ||
(merge_args == (MARG1_LCL | MARG2_GBL)) ||
(merge_args == (MARG1_GBL | MARG2_LCL)) ||
(merge_args == (MARG1_GBL | MARG2_GBL)));
assert(!lvzwrite_block || 0 == lvzwrite_block->curr_subsc);
/* Need to protect value from stpgcol */
PUSH_MV_STENT(MVST_MVAL);
value = &mv_chain->mv_st_cont.mvs_mval;
value->mvtype = 0; /* initialize mval in the M-stack in case stp_gcol gets called before value gets initialized below */
if (MARG2_IS_GBL(merge_args))
{ /* Need to protect mkey returned from gvcst_queryget from stpgcol */
PUSH_MV_STENT(MVST_MVAL);
mkey = &mv_chain->mv_st_cont.mvs_mval;
mkey->mvtype = 0; /* initialize mval in M-stack in case stp_gcol gets called before mkey gets initialized below */
gvname_env_restore(mglvnp->gblp[IND2]);
/* now $DATA will be done for gvn2. op_gvdata input parameters are set in the form of some GBLREF */
op_gvdata(value);
dollardata_src = MV_FORCE_INT(value);
if (0 == dollardata_src)
{ /* nothing in source global */
UNDO_ACTIVE_LV;
POP_MV_STENT(); /* value */
POP_MV_STENT(); /* mkey */
if (MARG1_IS_GBL(merge_args))
gvname_env_restore(mglvnp->gblp[IND1]); /* store destination as naked indicator in gv_currkey */
merge_args = 0; /* Must reset to zero to reuse the Global */
return;
}
if (NULL == TREF(gv_mergekey2))
{ /* We need to initialize gvn2 (right hand side). */
GVKEY_INIT(TREF(gv_mergekey2), DBKEYSIZE(MAX_KEY_SZ));
}
org_glvn1_keysz = mglvnp->gblp[IND1]->s_gv_currkey->end + 1;
org_glvn2_keysz = gv_currkey->end + 1;
(TREF(gv_mergekey2))->end = gv_currkey->end;
(TREF(gv_mergekey2))->prev = gv_currkey->prev;
memcpy((TREF(gv_mergekey2))->base, gv_currkey->base, gv_currkey->end + 1);
if (MARG1_IS_GBL(merge_args))
{ /*==================== MERGE ^gvn1=^gvn2 =====================*/
if (mglvnp->gblp[IND2]->s_gv_target->nct != mglvnp->gblp[IND1]->s_gv_target->nct)
rts_error(VARLSTCNT(1) ERR_NCTCOLLDIFF);
/* if self merge then NOOP*/
if (!merge_desc_check()) /* will not proceed if one is descendant of another */
{
gvname_env_restore(mglvnp->gblp[IND1]); /* store destination as naked indicator in gv_currkey */
POP_MV_STENT(); /* value */
merge_args = 0; /* Must reset to zero to reuse the Global */
return;
}
nullcoll_src = mglvnp->gblp[IND2]->s_gv_cur_region->std_null_coll;
nullcoll_dst = mglvnp->gblp[IND1]->s_gv_cur_region->std_null_coll;
if (1 == dollardata_src || 11 == dollardata_src)
{
found = op_gvget(value); /* value of ^glvn2 */
if (found)
{ /* SET ^gvn1=^gvn2 */
gvname_env_restore(mglvnp->gblp[IND1]);
op_gvput(value);
/* Note: If ^gvn1's null_sub=ALLOWEXISTING and say ^gvn1("")=^gvn,
* this will give NULL_SUBC error
*/
}
}
check_for_null_subs = (NEVER != mglvnp->gblp[IND2]->s_gv_cur_region->null_subs) &&
(ALWAYS != mglvnp->gblp[IND1]->s_gv_cur_region->null_subs);
/* Traverse descendant of ^gvn2 and copy into ^gvn1 */
for (; ;)
{
if (outofband)
{
gvname_env_restore(mglvnp->gblp[IND1]); /* naked indicator is restored into gv_currkey */
outofband_action(FALSE);
}
/* Restore last key under ^gvn2 we worked */
gvname_env_restore(mglvnp->gblp[IND2]);
assert(0 == gv_currkey->base[gv_currkey->end - 1] && 0 == gv_currkey->base[gv_currkey->end]);
/* following is an attempt to find immidiate right sibling */
gv_currkey->base[gv_currkey->end] = 1;
gv_currkey->base[gv_currkey->end + 1] = 0;
gv_currkey->base[gv_currkey->end + 2] = 0;
gv_currkey->end += 2;
/* Do atomic $QUERY and $GET of current glvn2:
* mkey is a mstr which contains $QUERY result in database format (So no conversion necessary)
* value is a mstr which contains $GET result
*/
if (!op_gvqueryget(mkey, value))
break;
assert(MV_IS_STRING(mkey));
if (mkey->str.len < org_glvn2_keysz)
break;
if (0 != *((unsigned char *)mkey->str.addr + (TREF(gv_mergekey2))->end - 1) ||
memcmp(mkey->str.addr, (TREF(gv_mergekey2))->base, (TREF(gv_mergekey2))->end - 1))
break; /* mkey is not under the sub-tree */
delta2 = mkey->str.len - org_glvn2_keysz; /* length increase of source key */
assert (0 < delta2);
/* Save the new source key for next iteration */
memcpy(mglvnp->gblp[IND2]->s_gv_currkey->base + org_glvn2_keysz - 2,
mkey->str.addr + org_glvn2_keysz - 2, delta2 + 2);
mglvnp->gblp[IND2]->s_gv_currkey->end = mkey->str.len - 1;
/* Create the destination key for this iteration (under ^glvn1) */
gvname_env_restore(mglvnp->gblp[IND1]);
if (gv_cur_region->max_key_size < org_glvn1_keysz + delta2)
ISSUE_GVSUBOFLOW_ERROR(gv_currkey);
assert(gv_currkey->end == org_glvn1_keysz - 1);
memcpy(gv_currkey->base + org_glvn1_keysz - 2,
mkey->str.addr + org_glvn2_keysz - 2, delta2 + 2);
gv_currkey->end = org_glvn1_keysz + delta2 - 1;
if (nullcoll_src != nullcoll_dst)
{
if (0 == nullcoll_dst)
{ /* Standard to GTM null subscript conversion*/
STD2GTMNULLCOLL((unsigned char *)gv_currkey->base + org_glvn1_keysz - 1,
delta2 - 1);
} else
{ /* GTM to standard null subscript conversion */
GTM2STDNULLCOLL((unsigned char *)gv_currkey->base + org_glvn1_keysz - 1,
delta2 - 1);
}
}
/* check null subscripts in destination key, note that we have already restored, destination global
* and curresponding region, key information
*/
if (check_for_null_subs)
{
ptr2 = gv_currkey->base + gv_currkey->end - 1;
for (ptr = gv_currkey->base + org_glvn1_keysz - 2; ptr < ptr2; )
{
if (KEY_DELIMITER == *ptr++ && KEY_DELIMITER == *(ptr + 1) &&
(0 == gv_cur_region->std_null_coll ? (STR_SUB_PREFIX == *ptr) :
(SUBSCRIPT_STDCOL_NULL == *ptr)))
/* Note: For sgnl_gvnulsubsc/rts_error
* we do not restore proper naked indicator.
* The standard states that the effect of a MERGE command
* on the naked indicator is that the naked indicator will be changed
* as if a specific SET command would have been executed.
* The standard also states that the effect on the naked indicator
* will only take be visible after the MERGE command has completed.
* So, if there is an error during the execution of a MERGE command,
* the standard allows the naked indicator to reflect any intermediate
* state. This provision was made intentionally, otherwise it would
* have become nearly impossible to create a fully standard
* implementation. : From Ed de Moel : 2/1/2
*/
sgnl_gvnulsubsc();
}
}
/* Now put value of ^glvn2 descendant into corresponding descendant under ^glvn1 */
op_gvput(value);
}
gvname_env_restore(mglvnp->gblp[IND1]); /* store destination as naked indicator in gv_currkey */
} else
{ /*==================== MERGE lvn1=^gvn2 =====================*/
assert(MARG1_IS_LCL(merge_args));
assert(mglvnp->lclp[IND1]);
/* Need to protect subsc created from global variable subscripts from stpgcol */
PUSH_MV_STENT(MVST_MVAL);
subsc = &mv_chain->mv_st_cont.mvs_mval;
/* Restore ^gvn2 we will work */
gvname_env_save(mglvnp->gblp[IND2]);
if (1 == dollardata_src || 11 == dollardata_src)
{ /* SET lvn1=^gvn2 */
found = op_gvget(value);
if (found)
mglvnp->lclp[IND1]->v = *value;
}
for (; ;)
{
if (outofband)
{
gvname_env_restore(mglvnp->gblp[IND2]); /* naked indicator is restored into gv_currkey */
outofband_action(FALSE);
}
assert(0 == gv_currkey->base[gv_currkey->end - 1] && 0 == gv_currkey->base[gv_currkey->end]);
/* following is an attempt to find immidiate right sibling */
gv_currkey->base[gv_currkey->end] = 1;
gv_currkey->base[gv_currkey->end + 1] = 0;
gv_currkey->base[gv_currkey->end + 2] = 0;
gv_currkey->end += 2;
/* Do $QUERY and $GET of current glvn2. Result will be in mkey and value respectively.
* mkey->str contains data as database format. So no conversion necessary
*/
if (!op_gvqueryget(mkey, value))
break;
if (mkey->str.len < (TREF(gv_mergekey2))->end + 1)
break;
ptr = (unsigned char *)mkey->str.addr + (TREF(gv_mergekey2))->end - 1;
if (0 != *ptr || memcmp(mkey->str.addr, (TREF(gv_mergekey2))->base, (TREF(gv_mergekey2))->end - 1))
break;
assert(MV_IS_STRING(mkey));
delta2 = mkey->str.len - org_glvn2_keysz; /* length increase of key */
assert (0 < delta2);
/* Create next key for ^glvn2 */
memcpy(gv_currkey->base + org_glvn2_keysz - 2, mkey->str.addr + org_glvn2_keysz - 2, delta2 + 2);
gv_currkey->end = mkey->str.len - 1;
/* Now add subscripts to create the entire key */
dst_lv = mglvnp->lclp[IND1];
is_base_var = LV_IS_BASE_VAR(dst_lv);
ptr = (unsigned char *)gv_currkey->base + org_glvn2_keysz - 1;
assert(*ptr);
do
{
LV_SBS_DEPTH(dst_lv, is_base_var, sbs_depth);
if (MAX_LVSUBSCRIPTS <= sbs_depth)
rts_error(VARLSTCNT(3) ERR_MERGEINCOMPL, 0, ERR_MAXNRSUBSCRIPTS);
ptr2 = gvsub2str(ptr, buff, FALSE);
subsc->mvtype = MV_STR;
subsc->str.addr = (char *)buff;
subsc->str.len = INTCAST(ptr2 - buff);
s2pool(&subsc->str);
dst_lv = op_putindx(VARLSTCNT(2) dst_lv, subsc);
while (*ptr++); /* skip to start of next subscript */
is_base_var = FALSE;
} while (*ptr);
/* We created the key. Pre-process the node in case a container is being replaced,
* then assign the value directly. Note there is no need to worry about MV_ALIASCONT
* propagation since the source in this case is a global var.
*/
DECR_AC_REF(dst_lv, TRUE);
dst_lv->v = *value;
}
gvname_env_restore(mglvnp->gblp[IND2]); /* naked indicator is restored into gv_currkey */
POP_MV_STENT(); /* subsc */
}
POP_MV_STENT(); /* mkey */
} else
{ /* source is local */
op_fndata(mglvnp->lclp[IND2], value);
dollardata_src = MV_FORCE_INT(value);
if (0 == dollardata_src)
{
UNDO_ACTIVE_LV;
POP_MV_STENT(); /* value */
if (MARG1_IS_GBL(merge_args))
gvname_env_restore(mglvnp->gblp[IND1]); /* store destination as naked indicator in gv_currkey */
merge_args = 0; /* Must reset to zero to reuse the Global */
return;
}
/* not memsetting output to 0 here can cause garbage value of output.out_var.lv.child which in turn can
* cause a premature return from lvzwr_var resulting in op_merge() returning without having done the merge.
*/
memset(&output, 0, SIZEOF(output));
if (MARG1_IS_LCL(merge_args))
{ /*==================== MERGE lvn1=lvn2 =====================*/
assert(mglvnp->lclp[IND1]);
/* if self merge then NOOP */
if (!merge_desc_check()) /* will not proceed if one is descendant of another */
{
POP_MV_STENT(); /* value */
merge_args = 0; /* Must reset to zero to reuse the Global */
return;
}
output.buff = (char *)buff;
output.ptr = output.buff;
output.out_var.lv.lvar = mglvnp->lclp[IND1];
zwr_output = &output;
lvzwr_init(zwr_patrn_mident, &mglvnp->lclp[IND2]->v);
lvzwr_arg(ZWRITE_ASTERISK, 0, 0);
lvzwr_var(mglvnp->lclp[IND2], 0);
/* assert that destination got all data of the source and its descendants */
DEBUG_ONLY(op_fndata(mglvnp->lclp[IND1], value));
DEBUG_ONLY(dollardata_dst = MV_FORCE_INT(value));
assert((dollardata_src & dollardata_dst) == dollardata_src);
} else
{ /*==================== MERGE ^gvn1=lvn2 =====================*/
assert(MARG1_IS_GBL(merge_args) && MARG2_IS_LCL(merge_args));
gvname_env_save(mglvnp->gblp[IND1]);
output.buff = (char *)buff;
output.ptr = output.buff;
output.out_var.gv.end = gv_currkey->end;
output.out_var.gv.prev = gv_currkey->prev;
zwr_output = &output;
lvzwr_init(zwr_patrn_mident, &mglvnp->lclp[IND2]->v);
lvzwr_arg(ZWRITE_ASTERISK, 0, 0);
lvzwr_var(mglvnp->lclp[IND2], 0);
gvname_env_restore(mglvnp->gblp[IND1]); /* store destination as naked indicator in gv_currkey */
}
}
POP_MV_STENT(); /* value */
merge_args = 0; /* Must reset to zero to reuse the Global */
}
