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; }