long SDMRegister::Marshal(char *buf)
{
int cur = HEADER_SIZE;
PUT_SHORT(&buf[cur], sensorIndex);
cur += sizeof(short);
msg_length = cur - HEADER_SIZE;
MarshalHeader(buf);
return cur;
}
long SDMService::Marshal(char* buf)
{
int cur;
cur = HEADER_SIZE;
cur += source.Marshal(buf,cur);
cur += destination.Marshal(buf,cur);
cur += command_id.Marshal(buf, cur);
PUT_SHORT(&buf[cur],seq_num);
cur += sizeof(seq_num);
memcpy(buf+cur,&data,length);
cur += length;
msg_length = cur-HEADER_SIZE;
MarshalHeader(buf);
return cur;
}
void* Publisher(void * args)
{
int published = 0;
short data;
while(published < 10)
{
data = (short)(rand()&0x00FF);
char bufdata[2];
PUT_SHORT(bufdata, data);
pthread_mutex_lock(&subscription_mutex);
if (subscriptions.Publish(1,1,bufdata,2))
{
published++;
}
pthread_mutex_unlock(&subscription_mutex);
printf("Produced %d\tPublished %d / 10\n",data,published);
sleep(1);
}
return NULL;
}
static gchar *encode_custom_data(struct custom_data *d, gint *len)
{
gint i, j;
#define PUT_BUF(_x) do { if (enc_buf_cnt < ENC_BUF_SIZE) enc_buffer[enc_buf_cnt++] = _x; else return NULL; } while (0)
#define PUT_SHORT(_x) do { if (enc_buf_cnt < ENC_BUF_SIZE-1) { \
enc_buffer[enc_buf_cnt++] = _x >> 8; enc_buffer[enc_buf_cnt++] = _x & 0xff; } \
else return NULL; } while (0)
enc_buf_cnt = 0;
PUT_BUF(CD_VERSION);
PUT_BUF(0);
PUT_BUF(CD_NAME_LONG);
PUT_BUF(64);
memcpy(&enc_buffer[enc_buf_cnt], d->name_long, 64);
enc_buf_cnt += 64;
PUT_BUF(CD_NAME_SHORT);
PUT_BUF(16);
memcpy(&enc_buffer[enc_buf_cnt], d->name_short, 16);
enc_buf_cnt += 16;
PUT_BUF(CD_COMPETITORS_MIN);
PUT_SHORT(d->competitors_min);
PUT_BUF(CD_COMPETITORS_MAX);
PUT_SHORT(d->competitors_max);
if (d->num_round_robin_pools) {
PUT_BUF(CD_NUM_RR_POOLS);
PUT_BUF(d->num_round_robin_pools);
for (i = 0; i < d->num_round_robin_pools; i++) {
PUT_BUF(CD_RR_POOL);
PUT_BUF(16);
memcpy(&enc_buffer[enc_buf_cnt], d->round_robin_pools[i].name, 16);
enc_buf_cnt += 16;
PUT_BUF(CD_RR_POOL_NUM_MATCHES);
PUT_SHORT(d->round_robin_pools[i].num_rr_matches);
for (j = 0; j < d->round_robin_pools[i].num_rr_matches; j++) {
PUT_BUF(CD_RR_POOL_MATCH);
PUT_SHORT(d->round_robin_pools[i].rr_matches[j]);
}
PUT_BUF(CD_RR_POOL_NUM_COMPETITORS);
PUT_SHORT(d->round_robin_pools[i].num_competitors);
for (j = 0; j < d->round_robin_pools[i].num_competitors; j++) {
gint k;
PUT_BUF(CD_COMP);
PUT_BUF(CD_COMP_TYPE);
PUT_BUF(d->round_robin_pools[i].competitors[j].type);
PUT_BUF(CD_COMP_NUM);
PUT_SHORT(d->round_robin_pools[i].competitors[j].num);
PUT_BUF(CD_COMP_POS);
PUT_BUF(d->round_robin_pools[i].competitors[j].pos);
PUT_BUF(CD_COMP_PREV);
for (k = 0; k < 8; k++)
PUT_BUF(d->round_robin_pools[i].competitors[j].prev[k]);
}
}
}
if (d->num_best_of_three_pairs) {
PUT_BUF(CD_NUM_B3_POOLS);
PUT_BUF(d->num_best_of_three_pairs);
for (i = 0; i < d->num_best_of_three_pairs; i++) {
PUT_BUF(CD_BEST_OF_3_PAIR);
PUT_BUF(16);
memcpy(&enc_buffer[enc_buf_cnt], d->best_of_three_pairs[i].name, 16);
enc_buf_cnt += 16;
for (j = 0; j < 3; j++) {
PUT_SHORT(d->best_of_three_pairs[i].matches[j]);
}
}
}
if (d->num_matches) {
PUT_BUF(CD_NUM_MATCHES);
PUT_SHORT(d->num_matches);
for (i = 0; i < d->num_matches; i++) {
PUT_BUF(CD_MATCH);
PUT_BUF(CD_MATCH_COMP_1);
PUT_BUF(CD_COMP_TYPE);
PUT_BUF(d->matches[i].c1.type);
PUT_BUF(CD_COMP_NUM);
PUT_SHORT(d->matches[i].c1.num);
PUT_BUF(CD_COMP_POS);
PUT_BUF(d->matches[i].c1.pos);
PUT_BUF(CD_COMP_PREV);
for (j = 0; j < 8; j++)
PUT_BUF(d->matches[i].c1.prev[j]);
PUT_BUF(CD_MATCH_COMP_2);
PUT_BUF(CD_COMP_TYPE);
PUT_BUF(d->matches[i].c2.type);
PUT_BUF(CD_COMP_NUM);
PUT_SHORT(d->matches[i].c2.num);
PUT_BUF(CD_COMP_POS);
PUT_BUF(d->matches[i].c2.pos);
PUT_BUF(CD_COMP_PREV);
for (j = 0; j < 8; j++)
PUT_BUF(d->matches[i].c2.prev[j]);
}
}
if (d->num_positions) {
PUT_BUF(CD_NUM_POSITIONS);
PUT_SHORT(d->num_positions);
for (i = 0; i < d->num_positions; i++) {
PUT_BUF(CD_POSITIONS);
PUT_BUF(CD_POSITIONS_TYPE);
PUT_BUF(d->positions[i].type);
PUT_BUF(CD_POSITIONS_MATCH);
PUT_SHORT(d->positions[i].match);
PUT_BUF(CD_POSITIONS_POS);
PUT_BUF(d->positions[i].pos);
PUT_BUF(CD_POSITIONS_REAL_POS);
PUT_BUF(d->positions[i].real_contest_pos);
}
}
if (d->num_groups) {
PUT_BUF(CD_NUM_GROUPS);
PUT_BUF(d->num_groups);
for (i = 0; i < d->num_groups; i++) {
PUT_BUF(CD_GROUP_NUM_COMP);
PUT_BUF(d->groups[i].type);
PUT_SHORT(d->groups[i].num_competitors);
for (j = 0; j < d->groups[i].num_competitors; j++)
PUT_SHORT(d->groups[i].competitors[j]);
}
}
*len = enc_buf_cnt;
return enc_buffer;
}
static BOOL GRPFILE_DoWriteGroupFile(HFILE file, PROGGROUP *group)
{
CHAR buffer[34];
HLOCAL hProgram;
INT NumProg, Title, Progs, Icons, Extension;
INT CurrProg, CurrIcon, nCmdShow, ptr, seqnum;
DWORD sizeAnd, sizeXor;
BOOL need_extension;
LPCSTR lpszTitle = LocalLock(group->hName);
UINT16 checksum;
GRPFILE_InitChecksum();
/* Calculate offsets */
NumProg = 0;
Icons = 0;
Extension = 0;
need_extension = FALSE;
hProgram = group->hPrograms;
while(hProgram)
{
PROGRAM *program = LocalLock(hProgram);
LPCSTR lpszWorkDir = LocalLock(program->hWorkDir);
NumProg++;
GRPFILE_CalculateSizes(program, &Icons, &Extension, &sizeAnd, &sizeXor);
/* Set a flag if an extension is needed */
if (lpszWorkDir[0] || program->nHotKey ||
program->nCmdShow != SW_SHOWNORMAL) need_extension = TRUE;
hProgram = program->hNext;
}
Title = 34 + NumProg * 2;
Progs = Title + lstrlen(lpszTitle) + 1;
Icons += Progs;
Extension += Icons;
/* Header */
buffer[0] = 'P';
buffer[1] = 'M';
buffer[2] = 'C';
buffer[3] = 'C';
PUT_SHORT(buffer, 4, 0); /* Checksum zero for now, written later */
PUT_SHORT(buffer, 6, Extension);
/* Update group->nCmdShow */
if (IsIconic(group->hWnd)) nCmdShow = SW_SHOWMINIMIZED;
else if (IsZoomed(group->hWnd)) nCmdShow = SW_SHOWMAXIMIZED;
else nCmdShow = SW_SHOWNORMAL;
PUT_SHORT(buffer, 8, nCmdShow);
PUT_SHORT(buffer, 10, group->x);
PUT_SHORT(buffer, 12, group->y);
PUT_SHORT(buffer, 14, group->width);
PUT_SHORT(buffer, 16, group->height);
PUT_SHORT(buffer, 18, group->iconx);
PUT_SHORT(buffer, 20, group->icony);
PUT_SHORT(buffer, 22, Title);
PUT_SHORT(buffer, 24, 0x0020); /* unknown */
PUT_SHORT(buffer, 26, 0x0020); /* unknown */
PUT_SHORT(buffer, 28, 0x0108); /* unknown */
PUT_SHORT(buffer, 30, 0x0000); /* unknown */
PUT_SHORT(buffer, 32, NumProg);
if ((UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, buffer, 34)) return FALSE;
/* Program table */
CurrProg = Progs;
CurrIcon = Icons;
hProgram = group->hPrograms;
while(hProgram)
{
PROGRAM *program = LocalLock(hProgram);
PUT_SHORT(buffer, 0, CurrProg);
if ((UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, buffer, 2))
return FALSE;
GRPFILE_CalculateSizes(program, &CurrProg, &CurrIcon, &sizeAnd, &sizeXor);
hProgram = program->hNext;
}
/* Title */
if ((UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, lpszTitle,
lstrlen(lpszTitle) + 1))
return FALSE;
/* Program entries */
CurrProg = Progs;
CurrIcon = Icons;
hProgram = group->hPrograms;
while(hProgram)
{
PROGRAM *program = LocalLock(hProgram);
LPCSTR Name = LocalLock(program->hName);
LPCSTR CmdLine = LocalLock(program->hCmdLine);
LPCSTR IconFile = LocalLock(program->hIconFile);
INT next_prog = CurrProg;
INT next_icon = CurrIcon;
GRPFILE_CalculateSizes(program, &next_prog, &next_icon, &sizeAnd, &sizeXor);
PUT_SHORT(buffer, 0, program->x);
PUT_SHORT(buffer, 2, program->y);
PUT_SHORT(buffer, 4, program->nIconIndex);
PUT_SHORT(buffer, 6, 0x048c); /* unknown */
PUT_SHORT(buffer, 8, sizeXor);
PUT_SHORT(buffer, 10, sizeAnd * 8);
PUT_SHORT(buffer, 12, CurrIcon);
PUT_SHORT(buffer, 14, CurrIcon + 12 + sizeAnd);
PUT_SHORT(buffer, 16, CurrIcon + 12);
ptr = CurrProg + 24;
PUT_SHORT(buffer, 18, ptr);
ptr += lstrlen(Name) + 1;
PUT_SHORT(buffer, 20, ptr);
ptr += lstrlen(CmdLine) + 1;
PUT_SHORT(buffer, 22, ptr);
if ((UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, buffer, 24) ||
(UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, Name, lstrlen(Name) + 1) ||
(UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, CmdLine, lstrlen(CmdLine) + 1) ||
(UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, IconFile, lstrlen(IconFile) + 1))
return FALSE;
CurrProg = next_prog;
CurrIcon = next_icon;
hProgram = program->hNext;
}
/* Icons */
#if 0 /* FIXME: this is broken anyway */
hProgram = group->hPrograms;
while(hProgram)
{
PROGRAM *program = LocalLock(hProgram);
CURSORICONINFO *iconinfo = LocalLock(program->hIcon);
LPVOID XorBits, AndBits;
INT sizeXor = iconinfo->nHeight * iconinfo->nWidthBytes;
INT sizeAnd = iconinfo->nHeight * ((iconinfo->nWidth + 15) / 16 * 2);
/* DumpIcon16(LocalLock(program->hIcon), 0, &XorBits, &AndBits);*/
PUT_SHORT(buffer, 0, iconinfo->ptHotSpot.x);
PUT_SHORT(buffer, 2, iconinfo->ptHotSpot.y);
PUT_SHORT(buffer, 4, iconinfo->nWidth);
PUT_SHORT(buffer, 6, iconinfo->nHeight);
PUT_SHORT(buffer, 8, iconinfo->nWidthBytes);
buffer[10] = iconinfo->bPlanes;
buffer[11] = iconinfo->bBitsPerPixel;
if ((UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, buffer, 12) ||
(UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, AndBits, sizeAnd) ||
(UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, XorBits, sizeXor)) return FALSE;
hProgram = program->hNext;
}
#endif
if (need_extension)
{
/* write `PMCC' extension */
PUT_SHORT(buffer, 0, 0x8000);
PUT_SHORT(buffer, 2, 0xffff);
PUT_SHORT(buffer, 4, 0x000a);
buffer[6] = 'P', buffer[7] = 'M';
buffer[8] = 'C', buffer[9] = 'C';
if ((UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, buffer, 10))
return FALSE;
seqnum = 0;
hProgram = group->hPrograms;
while(hProgram)
{
PROGRAM *program = LocalLock(hProgram);
LPCSTR lpszWorkDir = LocalLock(program->hWorkDir);
/* Working directory */
if (lpszWorkDir[0])
{
PUT_SHORT(buffer, 0, 0x8101);
PUT_SHORT(buffer, 2, seqnum);
PUT_SHORT(buffer, 4, 7 + lstrlen(lpszWorkDir));
if ((UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, buffer, 6) ||
(UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, lpszWorkDir, lstrlen(lpszWorkDir) + 1))
return FALSE;
}
/* Hot key */
if (program->nHotKey)
{
PUT_SHORT(buffer, 0, 0x8102);
PUT_SHORT(buffer, 2, seqnum);
PUT_SHORT(buffer, 4, 8);
PUT_SHORT(buffer, 6, program->nHotKey);
if ((UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, buffer, 8)) return FALSE;
}
/* Show command */
if (program->nCmdShow)
{
PUT_SHORT(buffer, 0, 0x8103);
PUT_SHORT(buffer, 2, seqnum);
PUT_SHORT(buffer, 4, 8);
PUT_SHORT(buffer, 6, program->nCmdShow);
if ((UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, buffer, 8)) return FALSE;
}
seqnum++;
hProgram = program->hNext;
}
/* Write `End' extension */
PUT_SHORT(buffer, 0, 0xffff);
PUT_SHORT(buffer, 2, 0xffff);
PUT_SHORT(buffer, 4, 0x0000);
if ((UINT)HFILE_ERROR == GRPFILE_WriteWithChecksum(file, buffer, 6)) return FALSE;
}
checksum = GRPFILE_GetChecksum();
_llseek(file, 4, SEEK_SET);
PUT_SHORT(buffer, 0, checksum);
_lwrite(file, buffer, 2);
return TRUE;
}
void dse_rmrec(void)
{
block_id blk;
blk_segment *bs1, *bs_ptr;
int4 blk_seg_cnt, blk_size, count;
sm_uc_ptr_t bp;
uchar_ptr_t lbp, b_top, rp, r_top, key_top, rp_base;
char cc, comp_key[256], cc_base;
short int size, i, rsize;
cw_set_element *cse;
error_def(ERR_DSEFAIL);
error_def(ERR_DSEBLKRDFAIL);
error_def(ERR_DBRDONLY);
if (gv_cur_region->read_only)
rts_error(VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region));
assert(update_array);
/* reset new block mechanism */
update_array_ptr = update_array;
if (cli_present("BLOCK") == CLI_PRESENT)
{
if(!cli_get_hex("BLOCK", &blk))
return;
if (blk < 0 || blk >= cs_addrs->ti->total_blks || !(blk % cs_addrs->hdr->bplmap))
{
util_out_print("Error: invalid block number.", TRUE);
return;
}
patch_curr_blk = blk;
}
if (cli_present("COUNT") == CLI_PRESENT)
{
if (!cli_get_hex("COUNT", &count) || count < 1)
return;
} else
count = 1;
t_begin_crit(ERR_DSEFAIL);
blk_size = cs_addrs->hdr->blk_size;
if(!(bp = t_qread(patch_curr_blk, &dummy_hist.h[0].cycle, &dummy_hist.h[0].cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
lbp = (uchar_ptr_t)malloc(blk_size);
memcpy(lbp, bp, blk_size);
if (((blk_hdr_ptr_t)lbp)->bsiz > cs_addrs->hdr->blk_size)
b_top = lbp + cs_addrs->hdr->blk_size;
else if (((blk_hdr_ptr_t)lbp)->bsiz < sizeof(blk_hdr))
b_top = lbp + sizeof(blk_hdr);
else
b_top = lbp + ((blk_hdr_ptr_t)lbp)->bsiz;
if (cli_present("RECORD") == CLI_PRESENT)
{
if (!(rp = rp_base = skan_rnum(lbp, FALSE)))
{
free(lbp);
t_abort(gv_cur_region, cs_addrs);
return;
}
} else if (!(rp = rp_base = skan_offset(lbp, FALSE)))
{
free(lbp);
t_abort(gv_cur_region, cs_addrs);
return;
}
memcpy(&comp_key[0], &patch_comp_key[0], sizeof(patch_comp_key));
cc_base = patch_comp_count;
for ( ; ; )
{
GET_SHORT(rsize, &((rec_hdr_ptr_t)rp)->rsiz);
if (rsize < sizeof(rec_hdr))
r_top = rp + sizeof(rec_hdr);
else
r_top = rp + rsize;
if (r_top >= b_top)
{
if (count)
{ if (((blk_hdr_ptr_t) lbp)->levl)
util_out_print("Warning: removed a star record from the end of this block.", TRUE);
((blk_hdr_ptr_t)lbp)->bsiz = rp_base - lbp;
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, (uchar_ptr_t)lbp + sizeof(blk_hdr),
(int)((blk_hdr_ptr_t)lbp)->bsiz - sizeof(blk_hdr));
if (!BLK_FINI(bs_ptr, bs1))
{
util_out_print("Error: bad blk build.",TRUE);
free(lbp);
t_abort(gv_cur_region, cs_addrs);
return;
}
t_write(patch_curr_blk, (unsigned char *)bs1, 0, 0, bp, ((blk_hdr_ptr_t)lbp)->levl, TRUE, FALSE);
BUILD_AIMG_IF_JNL_ENABLED(cs_addrs, cs_data, non_tp_jfb_buff_ptr, cse);
t_end(&dummy_hist, 0);
free(lbp);
return;
}
r_top = b_top;
}
if (((blk_hdr_ptr_t)lbp)->levl)
key_top = r_top - sizeof(block_id);
else
{
for (key_top = rp + sizeof(rec_hdr); key_top < r_top; )
if (!*key_top++ && !*key_top++)
break;
}
if (((rec_hdr_ptr_t)rp)->cmpc > patch_comp_count)
cc = patch_comp_count;
else
cc = ((rec_hdr_ptr_t)rp)->cmpc;
size = key_top - rp - sizeof(rec_hdr);
if (size < 0)
size = 0;
else if (size > sizeof(patch_comp_key) - 2)
size = sizeof(patch_comp_key) - 2;
memcpy(&patch_comp_key[cc], rp + sizeof(rec_hdr), size);
patch_comp_count = cc + size;
if (--count >= 0)
{
rp = r_top;
continue;
}
size = (patch_comp_count < cc_base) ? patch_comp_count : cc_base;
for (i = 0; i < size && patch_comp_key[i] == comp_key[i]; i++)
;
((rec_hdr_ptr_t)rp_base)->cmpc = i;
rsize = r_top - key_top + sizeof(rec_hdr) + patch_comp_count - i;
PUT_SHORT(&((rec_hdr_ptr_t)rp_base)->rsiz, rsize);
memcpy(rp_base + sizeof(rec_hdr), &patch_comp_key[i], patch_comp_count - i);
memcpy(rp_base + sizeof(rec_hdr) + patch_comp_count - i, key_top, b_top - key_top);
((blk_hdr_ptr_t)lbp)->bsiz = rp_base + rsize - lbp + b_top - r_top;
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, (uchar_ptr_t)lbp + sizeof(blk_hdr), ((blk_hdr_ptr_t)lbp)->bsiz - sizeof(blk_hdr));
if (!BLK_FINI(bs_ptr, bs1))
{
util_out_print("Error: bad blk build.", TRUE);
free(lbp);
t_abort(gv_cur_region, cs_addrs);
return;
}
t_write(patch_curr_blk, (unsigned char *)bs1, 0, 0, bp, ((blk_hdr_ptr_t)lbp)->levl, TRUE, FALSE);
BUILD_AIMG_IF_JNL_ENABLED(cs_addrs, cs_data, non_tp_jfb_buff_ptr, cse);
t_end(&dummy_hist, 0);
free(lbp);
return;
}
}
