void mu_signal_process(char *command, int signal)
{
unsigned short slen;
int len, toprocess_id, save_errno;
char buff[256];
error_def(ERR_MUPCLIERR);
error_def(ERR_MUPIPSIG);
slen = sizeof(buff);
if (!cli_get_str("ID", buff, &slen))
mupip_exit(ERR_MUPCLIERR);
len = slen;
toprocess_id = asc2i((uchar_ptr_t)buff, len);
if (toprocess_id < 0)
{
util_out_print("Error converting !AD to a number", FLUSH, len, buff);
mupip_exit(ERR_MUPCLIERR);
} else
{
if (-1 == kill(toprocess_id, signal))
{
save_errno = errno;
util_out_print("Error issuing !AD to process !UL: !AZ", FLUSH,
LEN_AND_STR(command), toprocess_id, STRERROR(errno));
} else
{
util_out_print("!AD issued to process !UL", FLUSH, LEN_AND_STR(command), toprocess_id);
if (!MEMCMP_LIT(command, STOP_STR))
{
send_msg(VARLSTCNT(9) ERR_MUPIPSIG, 7, LEN_AND_STR(command), signal, process_id, process_id,
toprocess_id, toprocess_id);
}
}
}
return;
}
int main(int argc, char **argv)
{
int fd;
FILE *fp;
header_struct *header;
gd_addr *addr;
gd_region *region;
gd_segment *segment;
int4 *long_ptr;
uint4 size;
int i, alloc, extend, block, global, key, lock, record;
argv++;
alloc = 100;
extend = 100;
block = 1024;
global = 128;
lock = 20;
record = 256;
key = 64;
for (i = argc; i > 1; i--)
{
if (argv[0][0] != '-' || argv[0][1] == 'h')
{
PRINTF("syntax is dtgbldir [-abegklr] with each qualifier followed by a number\n");
PRINTF("and separated by spaces. i.e. dtgbldir -a100 -b2048 -l30\n");
PRINTF("-a is alloc [100] -b is block size [1024] -e is ext [100]\n");
PRINTF("-g is glo buff [128] -k is keysize [64] -l is lock [20]\n");
PRINTF("-r is rec size [256] -h prints this message\n");
PRINTF("The global directory is created as ./mumps.gld\n");
return 0;
}
switch (argv[0][1])
{
case 'a': if (-1 == (alloc = asc2i((uchar_ptr_t)&argv[0][2],strlen(argv[0]) - 2)))
{
PRINTF("Invalid value for -a: %s\n", &argv[0][2]);
return 0;
}
break;
case 'b': if (-1 == (block = asc2i((uchar_ptr_t)&argv[0][2],strlen(argv[0]) - 2)))
{
PRINTF("Invalid value for -b: %s\n", &argv[0][2]);
return 0;
}
break;
case 'e': if (-1 == (extend = asc2i((uchar_ptr_t)&argv[0][2],strlen(argv[0]) - 2)))
{
PRINTF("Invalid value for -e: %s\n", &argv[0][2]);
return 0;
}
break;
case 'g': if (-1 == (global = asc2i((uchar_ptr_t)&argv[0][2], strlen(argv[0]) - 2)))
{
PRINTF("Invalid value for -g: %s\n", &argv[0][2]);
return 0;
}
break;
case 'k': if (-1 == (key = asc2i((uchar_ptr_t)&argv[0][2],strlen(argv[0]) - 2)))
{
PRINTF("Invalid value for -k: %s\n", &argv[0][2]);
return 0;
}
break;
case 'l': if (-1 == (lock = asc2i((uchar_ptr_t)&argv[0][2],strlen(argv[0]) - 2)))
{
PRINTF("Invalid value for -l: %s\n", &argv[0][2]);
return 0;
}
break;
case 'r': if (-1 == (record = asc2i((uchar_ptr_t)&argv[0][2],strlen(argv[0]) - 2)))
{
PRINTF("Invalid value for -r: %s\n", &argv[0][2]);
return 0;
}
break;
default: PRINTF("unrecognized qualifier %s\n",argv[0]);
return 0;
}
argv++;
}
if (argc == 1)
{
PRINTF("syntax is dtgbldir [-abegklr] with each qualifier followed by a number\n");
PRINTF("and separated by spaces. i.e. dtgbldir -a100 -b2048 -l30\n");
PRINTF("-a is alloc [100] -b is block size [1024] -e is ext [100]\n");
PRINTF("-g is glo buff [128] -k is keysize [64] -l is lock [20]\n");
PRINTF("-r is rec size [256] -h prints this message\n");
PRINTF("The global directory is created as ./mumps.gld\n");
PRINTF("\n\nCreating default global directory\n");
}
if (record > (block / 2) - 4)
{
PRINTF("Record size %d is too large, block size %d will only support record size of %d\n",
record, block, (block / 2) - 4);
return 0;
}
if (key >= record)
{
PRINTF("Key size %d is too large, record size %d will only support key size of %d\n",
key, record, record - 1);
return 0;
}
if (lock > 100 || lock < 4)
{
PRINTF("Lock size %d is invalid, must be between 4 and 100\n", lock);
return 0;
}
if (block % DISK_BLOCK_SIZE)
{
PRINTF("Block size %d is invalid, must be a multiple of %d\n", block, DISK_BLOCK_SIZE);
return 0;
}
if (global < 64 || global > 4096)
{
PRINTF("Global value %d is invalid, must be between 64 and 4096\n", global);
return 0;
}
if (-1 == (fd = OPEN4("./mumps.gld", O_CREAT | O_EXCL | O_RDWR, 0600, 0 )))
{
PERROR("Error opening file");
return 0;
}
size = sizeof(header_struct) + sizeof(gd_addr) + 3 * sizeof(gd_binding) + 1 * sizeof(gd_region) + 1 * sizeof(gd_segment);
header = (header_struct *)malloc(ROUND_UP(size, DISK_BLOCK_SIZE));
memset(header, 0, ROUND_UP(size, DISK_BLOCK_SIZE));
header->filesize = size;
size = ROUND_UP(size, DISK_BLOCK_SIZE);
memcpy(header->label, GDE_LABEL_LITERAL, sizeof(GDE_LABEL_LITERAL));
addr = (gd_addr *)((char *)header + sizeof(header_struct));
addr->max_rec_size = 256;
addr->maps = (gd_binding*)(sizeof(gd_addr));
addr->n_maps = 3;
addr->regions = (gd_region*)((int4)(addr->maps) + 3 * sizeof(gd_binding));
addr->n_regions = 1;
addr->segments = (gd_segment*)((int4)(addr->regions) + sizeof(gd_region));
addr->n_segments = 1;
addr->link = 0;
addr->tab_ptr = 0;
addr->id = 0;
addr->local_locks = 0;
addr->end = (int4)(addr->segments + 1 * sizeof(gd_segment));
long_ptr = (int4*)((char*)addr + (int4)(addr->maps));
*long_ptr++ = 0x232FFFFF;
*long_ptr++ = 0xFFFFFFFF;
*long_ptr++ = (int4)addr->regions;
*long_ptr++ = 0x24FFFFFF;
*long_ptr++ = 0xFFFFFFFF;
*long_ptr++ = (int4)addr->regions;
*long_ptr++ = 0xFFFFFFFF;
*long_ptr++ = 0xFFFFFFFF;
*long_ptr++ = (int4)addr->regions;
region = (gd_region*)((char*)addr + (int4)(addr->regions));
segment = (gd_segment*)((char*)addr + (int4)(addr->segments));
region->rname_len = 7;
memcpy(region->rname,"DEFAULT",7);
region->dyn.offset = (int4)addr->segments;
region->max_rec_size = record;
region->max_key_size = key;
region->open = region->lock_write = region->null_subs = region->jnl_state = 0;
region->jnl_alq = region->jnl_deq = region->jnl_buffer_size = region->jnl_before_image = 0;
region->jnl_file_len = region->node = region->cmx_regnum = 0;
region->sec_size = 0;
segment->sname_len = 7;
memcpy(segment->sname,"DEFAULT",7);
memcpy(segment->fname,"mumps.dat",9);
segment->fname_len = 9;
segment->blk_size = block;
segment->allocation = alloc;
segment->ext_blk_count = extend;
segment->cm_blk = 0;
segment->lock_space = lock;
memcpy(segment->defext,".dat",4);
segment->global_buffers = global;
segment->buckets = 0;
segment->windows = 0;
segment->acc_meth = dba_bg;
segment->defer_time = 1;
segment->file_cntl = 0;
if (NULL == (fp = FDOPEN(fd,"r+")))
{
PERROR("Error doing fdopen on file");
return 0;
}
if (fseek(fp, (long)0, SEEK_SET))
{
PERROR("Error seeking on file");
return 0;
}
if (fwrite(header,1,size,fp) != size)
{
PERROR("Error writing to file");
return 0;
}
return 1;
}
char *ext2jnl(char *ptr, jnl_record *rec)
{
unsigned char *pool_save;
char *ret, ch;
int keylength, keystate, len, i, reclen, temp_reclen;
bool keepgoing;
mstr src, des;
jnl_record *temp_rec;
muextract_type exttype;
enum jnl_record_type rectype;
jrec_suffix *suffix;
ext_stop = ptr + strlen(ptr) + 1;
temp_rec = rec;
exttype = MUEXTRACT_TYPE(ptr);
assert((exttype >= 0) && (exttype < MUEXT_MAX_TYPES));
switch(exttype)
{
case MUEXT_SET:
if (in_tp)
{
if (0 == num_records)
{
num_records++;
rec->prefix.jrec_type = JRT_TSET;
}
else
rec->prefix.jrec_type = JRT_USET;
} else
rec->prefix.jrec_type = JRT_SET;
break;
case MUEXT_KILL:
if (in_tp)
{
if (0 == num_records)
{
num_records++;
rec->prefix.jrec_type = JRT_TKILL;
}
else
rec->prefix.jrec_type = JRT_UKILL;
} else
rec->prefix.jrec_type = JRT_KILL;
break;
case MUEXT_ZKILL:
if (in_tp)
{
if (0 == num_records)
{
num_records++;
rec->prefix.jrec_type = JRT_TZKILL;
}
else
rec->prefix.jrec_type = JRT_UZKILL;
} else
rec->prefix.jrec_type = JRT_ZKILL;
break;
case MUEXT_TSTART:
in_tp = TRUE;
num_records = 0;
return (char *)rec;
break;
case MUEXT_TCOMMIT:
rec->prefix.jrec_type = JRT_TCOM;
in_tp = FALSE;
break;
case MUEXT_PINI:
case MUEXT_PFIN:
case MUEXT_EOF:
case MUEXT_ZTSTART:
case MUEXT_ZTCOMMIT:
assert(FALSE);
ext_stop = ptr;
return (char *)rec;
break;
case MUEXT_NULL:
rec->prefix.jrec_type = JRT_NULL;
break;
default:
assert(FALSE);
ext_stop = ptr;
return (char *)rec;
break;
}
rectype = rec->prefix.jrec_type;
ptr = strtok(ptr, "\\"); /* get the rec-type field */
assert(NULL != ptr);
ptr = strtok(NULL, "\\"); /* get the time field */
assert(NULL != ptr);
ptr = strtok(NULL, "\\"); /* get the tn field */
assert(NULL != ptr);
rec->prefix.tn = asc2i((uchar_ptr_t)ptr, strlen(ptr));
ptr = strtok(NULL, "\\"); /* get the pid field */
assert(NULL != ptr);
ptr = strtok(NULL, "\\"); /* get the client pid field */
assert(NULL != ptr);
ptr = strtok(NULL, "\\"); /* get the token or jnl_seqno */
assert(NULL != ptr);
rec->jrec_null.jnl_seqno = asc2l((uchar_ptr_t)ptr, strlen(ptr));
if (MUEXT_NULL == exttype)
{
rec->jrec_null.prefix.forwptr = rec->jrec_null.suffix.backptr = NULL_RECLEN;
rec->jrec_null.suffix.suffix_code = JNL_REC_SUFFIX_CODE;
return ((char_ptr_t)rec) + NULL_RECLEN;
}
else if (MUEXT_TCOMMIT == exttype)
{
ptr = strtok(NULL, "\\"); /* get the participants */
ptr = strtok(NULL, "\\"); /* get the jnl_tid */
rec->jrec_tcom.jnl_tid[0] = 0;
if (NULL != ptr)
strcpy(rec->jrec_tcom.jnl_tid, ptr);
num_records = 0;
rec->jrec_tcom.prefix.forwptr = rec->jrec_tcom.suffix.backptr = TCOM_RECLEN;
rec->jrec_tcom.suffix.suffix_code = JNL_REC_SUFFIX_CODE;
return ((char_ptr_t)rec) + TCOM_RECLEN;
}
ptr = strtok(NULL, "\\"); /* get the key-value and data also */
assert(IS_SET_KILL_ZKILL(rectype));
assert(NULL != ptr);
/* this part is lifted from go_load. later think of having a common routine */
len = strlen(ptr);
keylength = 0; /* determine length of key */
keystate = 0;
keepgoing = TRUE;
while((keylength < len) && keepgoing) /* slightly different here from go_load since we can get kill records too */
{
ch = *(ptr + keylength);
keylength++;
switch (keystate)
{
case 0: /* in global name */
if ('=' == ch) /* end of key */
{
keylength--;
keepgoing = FALSE;
}
else if ('(' == ch) /* start of subscripts */
keystate = 1;
break;
case 1: /* in subscripts area, but out of "..." or $C(...) */
switch (ch)
{
case ')': /* end of subscripts ==> end of key */
keepgoing = FALSE;
break;
case '"': /* step into "..." */
keystate = 2;
break;
case '$': /* step into $C(...) */
assert(('C' == *(ptr + keylength)) || ('c' == *(ptr + keylength)));
assert('(' == *(ptr + keylength + 1));
keylength += 2;
keystate = 3;
break;
}
break;
case 2: /* in "..." */
if ('"' == ch)
{
switch (*(ptr + keylength))
{
case '"': /* "" */
keylength++;
break;
case '_': /* _$C(...) */
assert('$' == *(ptr + keylength + 1));
assert(('c' == *(ptr + keylength + 2)) || ('C' == *(ptr + keylength + 2)));
assert('(' == *(ptr + keylength + 3));
keylength += 4;
keystate = 3;
break;
default: /* step out of "..." */
keystate = 1;
}
}
break;
case 3: /* in $C(...) */
if (')' == ch)
{
if ('_' == *(ptr + keylength)) /* step into "..." */
{
assert('"' == *(ptr + keylength + 1));
keylength += 2;
keystate = 2;
break;
}
else
keystate = 1; /* step out of $C(...) */
}
break;
default:
assert(FALSE);
break;
}
}
REPL_DPRINT2("ext2jnl source:KEY=DATA:%s\n", ptr);
assert(keylength <= len);
str2gvkey_nogvfunc(ptr, keylength, gv_currkey);
rec->jrec_kill.mumps_node.length = gv_currkey->end;
memcpy(rec->jrec_kill.mumps_node.text, gv_currkey->base, gv_currkey->end);
temp_reclen = FIXED_UPD_RECLEN + rec->jrec_kill.mumps_node.length + sizeof(jnl_str_len_t);
if (IS_KILL_ZKILL(rectype))
{
temp_reclen += JREC_SUFFIX_SIZE;
reclen = ROUND_UP2(temp_reclen, JNL_REC_START_BNDRY);
memset((char_ptr_t)rec + temp_reclen - JREC_SUFFIX_SIZE, 0, reclen - temp_reclen);
suffix = (jrec_suffix *)((char_ptr_t)rec + reclen - JREC_SUFFIX_SIZE);
rec->prefix.forwptr = suffix->backptr = reclen;
suffix->suffix_code = JNL_REC_SUFFIX_CODE;
return (char_ptr_t)rec + reclen;
}
/* we have to get the data value now */
src.len = len - keylength - 1;
src.addr = ptr + (keylength + 1);
des.len = 0;
des.addr = (char_ptr_t)rec + temp_reclen + sizeof(jnl_str_len_t);
REPL_DPRINT3("ext2jnl JNL Format (before zwr2format): src : Len %d :: DATA:%s\n", src.len, src.addr);
REPL_DPRINT3("ext2jnl JNL Format (before zwr2format): des : Len %d :: DATA:%s\n", des.len, des.addr);
if (!zwr2format(&src, &des))
{
assert(FALSE);
return (char_ptr_t)rec;
}
REPL_DPRINT3("ext2jnl JNL Format : src : Len %d :: DATA:%s\n", src.len, src.addr);
REPL_DPRINT3("ext2jnl JNL Format : des : Len %d :: DATA:%s\n", des.len, des.addr);
PUT_MSTR_LEN((char_ptr_t)rec + temp_reclen, des.len);
temp_reclen += sizeof(jnl_str_len_t) + des.len + JREC_SUFFIX_SIZE;
reclen = ROUND_UP2(temp_reclen, JNL_REC_START_BNDRY);
memset((char_ptr_t)rec + temp_reclen - JREC_SUFFIX_SIZE, 0, reclen - temp_reclen);
suffix = (jrec_suffix *)((char_ptr_t)rec + reclen - JREC_SUFFIX_SIZE);
rec->prefix.forwptr = suffix->backptr = reclen;
suffix->suffix_code = JNL_REC_SUFFIX_CODE;
return (char_ptr_t)rec + reclen;
}
caddr_t util_format(caddr_t message, va_list fao, caddr_t buff, int4 size, int faocnt)
{
desc_struct *d;
signed char schar;
unsigned char type, type2;
caddr_t c, outptr, outtop;
uchar_ptr_t ret_ptr;
unsigned char uchar;
short sshort, *s;
unsigned short ushort;
int i, length, max_chars, field_width, repeat_count, int_val;
boolean_t indirect;
qw_num_ptr_t val_ptr;
unsigned char numa[22];
unsigned char *numptr;
VAR_COPY(last_va_list_ptr, fao);
outptr = buff;
outtop = outptr + size - 5; /* 5 bytes to prevent writing across border */
/* 5 comes from line 268 -- 278 */
while (outptr < outtop)
{
/* Look for the '!' that starts an FAO directive */
while ((schar = *message++) != '!')
{
if (schar == '\0')
{
VAR_COPY(last_va_list_ptr, fao);
return outptr;
}
*outptr++ = schar;
if (outptr >= outtop)
{
VAR_COPY(last_va_list_ptr, fao);
return outptr;
}
}
field_width = 0; /* Default values */
repeat_count = 1;
/* Look for a field width (or repeat count) */
if (*message == '#')
{
if (0 < faocnt)
field_width = repeat_count = va_arg(fao, int4);
++message;
} else
{
for (c = message; *c >= '0' && *c <= '9'; ++c)
;
if ((length = c - message) > 0)
{
field_width = repeat_count
= asc2i((uchar_ptr_t)message, length);
message = c;
}
}
if ('@' == *message) /* Indirectly addressed operand */
{
indirect = TRUE;
message++;
} else
indirect = FALSE;
switch (type = *message++)
{
case '/':
assert(!indirect);
*outptr++ = '\n';
continue;
case '_':
assert(!indirect);
*outptr++ = '\t';
continue;
case '^':
assert(!indirect);
*outptr++ = '\f';
continue;
case '!':
assert(!indirect);
*outptr++ = '!';
continue;
case '*':
assert(!indirect);
while ((repeat_count-- > 0) && (outptr < outtop))
*outptr++ = *message;
++message;
continue;
case 'A':
assert(!indirect);
switch(type2 = *message++)
{
case 'C':
GETFAOVALDEF(faocnt, fao, caddr_t, c, NULL);
length = c ? *c++ : 0;
break;
case 'D':
case 'F':
GETFAOVALDEF(faocnt, fao, int4, length, 0);
GETFAOVALDEF(faocnt, fao, caddr_t, c, NULL);
break;
case 'S':
if (faocnt)
{
d = (desc_struct *)va_arg(fao, caddr_t);
faocnt--;
c = d->addr;
length = d->len;
} else
{
c = NULL;
length = 0;
}
break;
case 'Z':
GETFAOVALDEF(faocnt, fao, caddr_t, c, NULL);
length = c ? strlen(c) : 0;
}
max_chars = MIN((outtop - outptr - 1),
(0 == field_width ? length : MIN(field_width, length)));
for (i = 0; i < max_chars; ++i, ++c)
if (type2 == 'F' && (*c < ' ' || *c > '~'))
*outptr++ = '.';
else if (*c == '\0')
--i; /* Don't count nul characters */
else
*outptr++ = *c;
assert(0 <= field_width);
assert(0 <= max_chars);
for (i = field_width - max_chars; i > 0; --i)
*outptr++ = ' ';
continue;
default: /* Rest of numeric types come here */
assert('S' == type || 'U' == type || 'X' == type || 'Z' == type);
numptr = numa;
type2 = *message++;
if (!indirect)
{
if ('S' == type)
switch(type2)
{
case 'B':
GETFAOVALDEF(faocnt, fao, int4, schar, 0);
int_val = schar;
break;
case 'W':
GETFAOVALDEF(faocnt, fao, int4, sshort, 0);
int_val = sshort;
break;
case 'L':
GETFAOVALDEF(faocnt, fao, int4, int_val, 0);
break;
default:
assert(FALSE);
}
else
{
GETFAOVALDEF(faocnt, fao, int4, int_val, 0);
switch(type2)
{
case 'B':
int_val = int_val & 0xFF;
break;
case 'W':
int_val = int_val & 0xFFFF;
break;
case 'L':
int_val = int_val & 0xFFFFFFFF;
break;
default:
assert(FALSE);
}
}
switch (type)
{
case 'S': /* Signed value. Give sign if need to */
if (0 > int_val)
{
*numptr++ = '-';
int_val = -(int_val);
} /* note fall into unsigned */
case 'U':
case 'Z': /* zero filled */
numptr = i2asc(numptr, int_val);
break;
case 'X': /* Hex */
switch (type2)
{ /* length is number of ascii hex chars */
case 'B':
length = sizeof(short);
break;
case 'W':
length = sizeof(int4);
break;
case 'L':
length = sizeof(int4) + sizeof(int4);
break;
default:
assert(FALSE);
}
i2hex(int_val, numptr, length);
numptr += length;
break;
default:
assert(FALSE);
}
} else
{
if ('X' == type) /* Support XH and XJ */
{
assert('H' == type2 || 'J' == type2);
GETFAOVALDEF(faocnt, fao, qw_num_ptr_t, val_ptr, NULL); /* Addr of long type */
if (val_ptr)
{
if (0 != field_width)
{
i2hexl(*val_ptr, numptr, field_width);
numptr += field_width;
} else
{
length = i2hexl_nofill(*val_ptr, numptr, HEX16);
numptr += length;
}
}
} else /* support ZH and ZJ */
{
if ('Z' != type)
GTMASSERT;
assert('H' == type2 || 'J' == type2);
GETFAOVALDEF(faocnt, fao, qw_num_ptr_t, val_ptr, NULL); /* Addr of long type */
if (val_ptr)
{
ret_ptr = i2ascl(numptr, *val_ptr);
length = ret_ptr - (uchar_ptr_t)numptr;
if (0 != field_width)
numptr += MIN(length, field_width);
else
numptr += length;
}
}
}
length = numptr - numa; /* Length of asciified number */
max_chars = MIN((outtop - outptr - 1),
(0 == field_width ? length : MIN(field_width, length)));
if (length < field_width)
{
memset(outptr, (('Z' == type) ? '0' : ' '), field_width - length);
outptr += field_width - length;
}
if ((field_width > 0) && (field_width < length))
{
memset(outptr, '*', field_width);
outptr += field_width;
} else
{
memcpy(outptr, numa, length);
outptr += length;
}
}
}
VAR_COPY(last_va_list_ptr, fao);
return outptr;
}
