int main(int argc, char *argv[])
{
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
set_blocksig();
gtm_imagetype_init(DSE_IMAGE);
gtm_wcswidth_fnptr = gtm_wcswidth;
gtm_env_init(); /* read in all environment variables */
licensed = TRUE;
TREF(transform) = TRUE;
op_open_ptr = op_open;
patch_curr_blk = get_dir_root();
err_init(util_base_ch);
GTM_ICU_INIT_IF_NEEDED; /* Note: should be invoked after err_init (since it may error out) and before CLI parsing */
sig_init(generic_signal_handler, dse_ctrlc_handler, suspsigs_handler);
atexit(util_exit_handler);
SET_LATCH_GLOBAL(&defer_latch, LOCK_AVAILABLE);
get_page_size();
stp_init(STP_INITSIZE);
rts_stringpool = stringpool;
getjobname();
INVOKE_INIT_SECSHR_ADDRS;
getzdir();
prealloc_gt_timers();
initialize_pattern_table();
gvinit();
region_init(FALSE);
INIT_GBL_ROOT(); /* Needed for GVT initialization */
getjobnum();
util_out_print("!/File !_!AD", TRUE, DB_LEN_STR(gv_cur_region));
util_out_print("Region!_!AD!/", TRUE, REG_LEN_STR(gv_cur_region));
cli_lex_setup(argc, argv);
CREATE_DUMMY_GBLDIR(gd_header, original_header, gv_cur_region, gd_map, gd_map_top);
gtm_chk_dist(argv[0]);
# ifdef DEBUG
if ((gtm_white_box_test_case_enabled && (WBTEST_SEMTOOLONG_STACK_TRACE == gtm_white_box_test_case_number) ))
{
sgmnt_addrs * csa;
node_local_ptr_t cnl;
csa = &FILE_INFO(gv_cur_region)->s_addrs;
cnl = csa->nl;
cnl->wbox_test_seq_num = 1; /*Signal the first step and wait here*/
while (2 != cnl->wbox_test_seq_num) /*Wait for another process to get hold of the semaphore and signal next step*/
LONG_SLEEP(10);
}
# endif
if (argc < 2)
display_prompt();
io_init(TRUE);
while (1)
{
if (!dse_process(argc))
break;
display_prompt();
}
dse_exit();
REVERT;
}
void lke(void)
{
char buff[MAX_LINE];
$DESCRIPTOR (command, buff);
uint4 status;
short len;
bool dcl;
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
gtm_imagetype_init(LKE_IMAGE);
gtm_env_init(); /* read in all environment variables */
util_out_open(0);
SET_EXIT_HANDLER(exi_blk, generic_exit_handler, exi_condition); /* Establish exit handler */
ESTABLISH(util_base_ch);
status =lp_id(&lkid);
if (SS$_NORMAL != status)
rts_error(VARLSTCNT(1) status);
get_page_size();
stp_init(STP_INITSIZE);
rts_stringpool = stringpool;
getjobname();
INVOKE_INIT_SECSHR_ADDRS;
ast_init();
initialize_pattern_table();
gvinit();
region_init(TRUE);
getjobnum();
status = lib$get_foreign(&command, 0, &len, 0);
if ((status & 1) && len > 0)
{
command.dsc$w_length = len;
status = CLI$DCL_PARSE(&command, &lke_cmd, &lib$get_input, 0, 0);
if (CLI$_NORMAL == status)
{
util_out_open(&output_qualifier);
CLI$DISPATCH();
util_out_close();
}
lke_exit();
}
for (;;)
lke_process();
}
int main (int argc, char *argv[])
{
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
set_blocksig();
gtm_imagetype_init(LKE_IMAGE);
gtm_wcswidth_fnptr = gtm_wcswidth;
gtm_env_init(); /* read in all environment variables */
licensed = TRUE;
err_init(util_base_ch);
GTM_ICU_INIT_IF_NEEDED; /* Note: should be invoked after err_init (since it may error out) and before CLI parsing */
sig_init(generic_signal_handler, lke_ctrlc_handler, suspsigs_handler);
atexit(util_exit_handler);
SET_LATCH_GLOBAL(&defer_latch, LOCK_AVAILABLE);
get_page_size();
stp_init(STP_INITSIZE);
rts_stringpool = stringpool;
getjobname();
INVOKE_INIT_SECSHR_ADDRS;
getzdir();
prealloc_gt_timers();
initialize_pattern_table();
gvinit();
region_init(TRUE);
getjobnum();
cli_lex_setup(argc, argv);
/* this should be after cli_lex_setup() due to S390 A/E conversion */
gtm_chk_dist(argv[0]);
while (1)
{
if (!lke_process(argc) || 2 <= argc)
break;
}
lke_exit();
}
/* On OSF/1 (Digital Unix), pointers are 64 bits wide; the only exception to this is C programs for which one may
* specify compiler and link editor options in order to use (and allocate) 32-bit pointers. However, since C is
* the only exception and, in particular because the operating system does not support such an exception, the argv
* array passed to the main program is an array of 64-bit pointers. Thus the C program needs to declare argv[]
* as an array of 64-bit pointers and needs to do the same for any pointer it sets to an element of argv[].
*/
void gtcm_init(int argc, char_ptr_t argv[])
{
char *ptr;
struct sigaction ignore, act;
void get_page_size();
int pid;
char msg[256];
int save_errno, maxfds;
/* Disassociate from the rest of the universe */
get_page_size();
gtm_wcswidth_fnptr = gtm_wcswidth;
# ifndef GTCM_DEBUG_NOBACKGROUND
FORK(pid);
if (0 > pid)
{
save_errno = errno;
SPRINTF(msg, "Unable to detach %s from controlling tty", SRVR_NAME);
gtcm_rep_err(msg, save_errno);
EXIT(-1);
}
else if (0 < pid)
EXIT(0);
(void) setpgrp();
# endif
/* Initialize logging */
omi_pid = getpid();
/* Initialize signals */
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
ignore = act;
ignore.sa_handler = SIG_IGN;
act.sa_handler = (void (*)()) gtcm_term;
(void) sigaction(SIGTERM, &act, 0);
act.sa_handler = (void (*)()) gtcm_dmpstat;
(void) sigaction(SIGUSR1, &act, 0);
(void) sigaction(SIGUSR2, &ignore, 0);
(void) sigaction(SIGALRM, &ignore, 0);
(void) sigaction(SIGPIPE, &ignore, 0);
(void) sigaction(SIGINT, &ignore, 0);
# ifdef GTCM_RC
act.sa_handler = gtcm_fail;
act.sa_flags = SA_RESETHAND;
/* restore signal handler to default action upon receipt
of signal */
(void) sigaction(SIGSEGV, &act, 0);
(void) sigaction(SIGBUS, &act, 0);
(void) sigaction(SIGILL, &act, 0);
(void) sigaction(SIGTRAP, &act, 0);
(void) sigaction(SIGABRT, &act, 0);
# ifndef __linux__
(void) sigaction(SIGEMT, &act, 0);
(void) sigaction(SIGSYS, &act, 0);
# endif
# endif
/* Initialize the process flags */
if (0 != gtcm_prsopt(argc, argv))
EXIT(-1);
/* Write down pid into log file */
OMI_DBG((omi_debug, "GTCM_SERVER pid : %d\n", omi_pid));
/* Initialize history mechanism */
if (history)
{
init_hist();
act.sa_handler = (void (*)())dump_rc_hist;
act.sa_flags = 0;
(void) sigaction(SIGUSR2, &act, 0);
}
/* Initialize the DBMS */
licensed = TRUE;
getjobnum();
getzdir();
if ((maxfds = getmaxfds()) < 0)
{
gtcm_rep_err("Unable to get system resource limits", errno);
EXIT(errno);
}
assert(SIZEOF(gtcm_ast_avail) == 2); /* check that short is size 2 bytes as following code relies on that */
gtcm_ast_avail = (maxfds > MAXINT2) ? MAXINT2 : maxfds;
stp_init(STP_INITSIZE);
rts_stringpool = stringpool;
curr_pattern = pattern_list = &mumps_pattern;
pattern_typemask = mumps_pattern.typemask;
INVOKE_INIT_SECSHR_ADDRS;
initialize_pattern_table();
/* Preallocate some timer blocks. */
prealloc_gt_timers();
gt_timers_add_safe_hndlrs();
/* Moved to omi_gvextnam, omi_lkextnam */
/* gvinit(); */
return;
}
void gtm_startup(struct startup_vector *svec)
/* Note: various references to data copied from *svec could profitably be referenced directly */
{
unsigned char *mstack_ptr;
void gtm_ret_code();
static readonly unsigned char init_break[1] = {'B'};
int4 lct;
int i;
static char other_mode_buf[] = "OTHER";
mstr log_name;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(INVALID_IMAGE != image_type);
assert(svec->argcnt == SIZEOF(*svec));
IA64_ONLY(init_xfer_table());
get_page_size();
cache_table_relobjs = &cache_table_rebuild;
ht_rhash_ch = &hashtab_rehash_ch;
jbxm_dump_ch = &jobexam_dump_ch;
heartbeat_timer_ptr = &heartbeat_timer;
stpgc_ch = &stp_gcol_ch;
rtn_fst_table = rtn_names = (rtn_tabent *)svec->rtn_start;
rtn_names_end = rtn_names_top = (rtn_tabent *)svec->rtn_end;
if (svec->user_stack_size < 4096)
svec->user_stack_size = 4096;
if (svec->user_stack_size > 8388608)
svec->user_stack_size = 8388608;
mstack_ptr = (unsigned char *)malloc(svec->user_stack_size);
msp = stackbase = mstack_ptr + svec->user_stack_size - mvs_size[MVST_STORIG];
/* mark the stack base so that if error occur during call-in gtm_init(), the unwind
* logic in gtmci_ch() will get rid of the stack completely
*/
fgncal_stack = stackbase;
mv_chain = (mv_stent *)msp;
mv_chain->mv_st_type = MVST_STORIG; /* Initialize first (anchor) mv_stent so doesn't do anything */
mv_chain->mv_st_next = 0;
mv_chain->mv_st_cont.mvs_storig = 0;
stacktop = mstack_ptr + 2 * mvs_size[MVST_NTAB];
stackwarn = stacktop + (16 * 1024);
break_message_mask = svec->break_message_mask;
if (svec->user_strpl_size < STP_INITSIZE)
svec->user_strpl_size = STP_INITSIZE;
else if (svec->user_strpl_size > STP_MAXINITSIZE)
svec->user_strpl_size = STP_MAXINITSIZE;
stp_init(svec->user_strpl_size);
if (svec->user_indrcache_size > MAX_INDIRECTION_NESTING || svec->user_indrcache_size < MIN_INDIRECTION_NESTING)
svec->user_indrcache_size = MIN_INDIRECTION_NESTING;
TREF(ind_result_array) = (mval **)malloc(SIZEOF(mval *) * svec->user_indrcache_size);
TREF(ind_source_array) = (mval **)malloc(SIZEOF(mval *) * svec->user_indrcache_size);
TREF(ind_result_sp) = TREF(ind_result_array);
TREF(ind_result_top) = TREF(ind_result_sp) + svec->user_indrcache_size;
TREF(ind_source_sp) = TREF(ind_source_array);
TREF(ind_source_top) = TREF(ind_source_sp) + svec->user_indrcache_size;
rts_stringpool = stringpool;
TREF(compile_time) = FALSE;
/* assert that is_replicator and run_time is properly set by gtm_imagetype_init invoked at process entry */
# ifdef DEBUG
switch (image_type)
{
case GTM_IMAGE:
case GTM_SVC_DAL_IMAGE:
assert(is_replicator && run_time);
break;
case MUPIP_IMAGE:
assert(!is_replicator && !run_time);
break;
default:
assert(FALSE);
}
# endif
gtm_utf8_init(); /* Initialize the runtime for Unicode */
/* Initialize alignment requirement for the runtime stringpool */
log_name.addr = DISABLE_ALIGN_STRINGS;
log_name.len = STR_LIT_LEN(DISABLE_ALIGN_STRINGS);
/* mstr_native_align = logical_truth_value(&log_name, FALSE, NULL) ? FALSE : TRUE; */
mstr_native_align = FALSE; /* TODO: remove this line and uncomment the above line */
getjobname();
INVOKE_INIT_SECSHR_ADDRS;
getzprocess();
getzmode();
geteditor();
zcall_init();
cmd_qlf.qlf = glb_cmd_qlf.qlf;
cache_init();
# ifdef __sun
if (NULL != GETENV(PACKAGE_ENV_TYPE)) /* chose xcall (default) or rpc zcall */
xfer_table[xf_fnfgncal] = (xfer_entry_t)op_fnfgncal_rpc; /* using RPC */
# endif
msp -= SIZEOF(stack_frame);
frame_pointer = (stack_frame *)msp;
memset(frame_pointer,0, SIZEOF(stack_frame));
frame_pointer->temps_ptr = (unsigned char *)frame_pointer;
frame_pointer->ctxt = GTM_CONTEXT(gtm_ret_code);
frame_pointer->mpc = CODE_ADDRESS(gtm_ret_code);
frame_pointer->type = SFT_COUNT;
frame_pointer->rvector = (rhdtyp*)malloc(SIZEOF(rhdtyp));
memset(frame_pointer->rvector, 0, SIZEOF(rhdtyp));
symbinit();
/* Variables for supporting $ZSEARCH sorting and wildcard expansion */
TREF(zsearch_var) = lv_getslot(curr_symval);
TREF(zsearch_dir1) = lv_getslot(curr_symval);
TREF(zsearch_dir2) = lv_getslot(curr_symval);
LVVAL_INIT((TREF(zsearch_var)), curr_symval);
LVVAL_INIT((TREF(zsearch_dir1)), curr_symval);
LVVAL_INIT((TREF(zsearch_dir2)), curr_symval);
/* Initialize global pointer to control-C handler. Also used in iott_use */
ctrlc_handler_ptr = &ctrlc_handler;
io_init(IS_MUPIP_IMAGE); /* starts with nocenable for GT.M runtime, enabled for MUPIP */
if (!IS_MUPIP_IMAGE)
{
sig_init(generic_signal_handler, ctrlc_handler_ptr, suspsigs_handler, continue_handler);
atexit(gtm_exit_handler);
cenable(); /* cenable unless the environment indicates otherwise - 2 steps because this can report errors */
}
jobinterrupt_init();
getzdir();
dpzgbini();
zco_init();
/* a base addr of 0 indicates a gtm_init call from an rpc server */
if ((GTM_IMAGE == image_type) && (NULL != svec->base_addr))
jobchild_init();
else
{ /* Trigger enabled utilities will enable through here */
(TREF(dollar_zmode)).mvtype = MV_STR;
(TREF(dollar_zmode)).str.addr = other_mode_buf;
(TREF(dollar_zmode)).str.len = SIZEOF(other_mode_buf) -1;
}
svec->frm_ptr = (unsigned char *)frame_pointer;
dollar_ztrap.mvtype = MV_STR;
dollar_ztrap.str.len = SIZEOF(init_break);
dollar_ztrap.str.addr = (char *)init_break;
dollar_zstatus.mvtype = MV_STR;
dollar_zstatus.str.len = 0;
dollar_zstatus.str.addr = NULL;
ecode_init();
zyerror_init();
ztrap_form_init();
ztrap_new_init();
zdate_form_init(svec);
dollar_system_init(svec);
init_callin_functable();
gtm_env_xlate_init();
SET_LATCH_GLOBAL(&defer_latch, LOCK_AVAILABLE);
curr_pattern = pattern_list = &mumps_pattern;
pattern_typemask = mumps_pattern.typemask;
initialize_pattern_table();
ce_init(); /* initialize compiler escape processing */
/* Initialize local collating sequence */
TREF(transform) = TRUE;
lct = find_local_colltype();
if (lct != 0)
{
TREF(local_collseq) = ready_collseq(lct);
if (!TREF(local_collseq))
{
exi_condition = -ERR_COLLATIONUNDEF;
gtm_putmsg(VARLSTCNT(3) ERR_COLLATIONUNDEF, 1, lct);
exit(exi_condition);
}
} else
TREF(local_collseq) = 0;
prealloc_gt_timers();
gt_timers_add_safe_hndlrs();
for (i = 0; FNPC_MAX > i; i++)
{ /* Initialize cache structure for $Piece function */
(TREF(fnpca)).fnpcs[i].pcoffmax = &(TREF(fnpca)).fnpcs[i].pstart[FNPC_ELEM_MAX];
(TREF(fnpca)).fnpcs[i].indx = i;
}
(TREF(fnpca)).fnpcsteal = (TREF(fnpca)).fnpcs; /* Starting place to look for cache reuse */
(TREF(fnpca)).fnpcmax = &(TREF(fnpca)).fnpcs[FNPC_MAX - 1]; /* The last element */
/* Initialize zwrite subsystem. Better to do it now when we have storage to allocate than
* if we fail and storage allocation may not be possible. To that end, pretend we have
* seen alias acitivity so those structures are initialized as well.
*/
assert(FALSE == curr_symval->alias_activity);
curr_symval->alias_activity = TRUE;
lvzwr_init((enum zwr_init_types)0, (mval *)NULL);
curr_symval->alias_activity = FALSE;
if ((NULL != (TREF(mprof_env_gbl_name)).str.addr))
turn_tracing_on(TADR(mprof_env_gbl_name), TRUE, (TREF(mprof_env_gbl_name)).str.len > 0);
return;
}
mupip()
{
unsigned int status;
int4 inid = 0;
int4 nid = 0; /* system ID, node number */
int4 days = 128; /* days to expiration */
int4 lic_x = 0; /* license value */
char *h = NULL; /* license data base */
char *pak = NULL; /* pak record */
int4 mdl = 0; /* hardw. model type */
$DESCRIPTOR(dprd, gtm_product);
$DESCRIPTOR(dver, gtm_version);
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
gtm_imagetype_init(MUPIP_IMAGE);
gtm_env_init(); /* read in all environment variables */
licensed = TRUE;
TREF(transform) = TRUE;
in_backup = FALSE;
util_out_open(0);
SET_EXIT_HANDLER(exi_blk, generic_exit_handler, exi_condition); /* Establish exit handler */
ESTABLISH(util_base_ch);
get_page_size();
getjobnum();
INVOKE_INIT_SECSHR_ADDRS;
# ifdef NOLICENSE
status = SS$_NORMAL;
lid = 1;
lic_x = 32767;
# else
if (NULL == (h = la_getdb(LMDB))) /* license db in mem */
status = LP_NOCNFDB;
else
status = SS$_NORMAL;
if (1 == (status & 1)) /* licensing: node+ system */
status = lm_mdl_nid(&mdl, &nid, &inid);
if (1 == (status & 1)) /* licensing: license */
{
dprd.dsc$w_length = gtm_product_len;
dver.dsc$w_length = gtm_version_len;
status = lp_licensed(h, &dprd, &dver, mdl, nid, &lid, &lic_x, &days, pak);
}
# endif
if (1 == (status & 1)) /* licensing: license units */
status = LP_ACQUIRE(pak, lic_x, lid, &lkid); /* def in cryptdef */
# ifdef NOLICENSE
status = SS$_NORMAL;
# else
if (LP_NOCNFDB != status)
la_freedb(h);
if (1 == (status & 1)) /* licensing */
{
if (days < 14)
lm_putmsgu(ERR_WILLEXPIRE, 0, 0);
}
else
{
licensed = FALSE;
if (LP_INVCSM != status)
rts_error(VARLSTCNT(1) status);
}
# endif
ast_init();
initialize_pattern_table();
INIT_GBL_ROOT();
stp_init(STP_INITSIZE);
rts_stringpool = stringpool;
mupip_getcmd();
mupip_exit(SS$_NORMAL);
}
int main(int argc, char *argv[])
{
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
common_startup_init(DSE_IMAGE);
licensed = TRUE;
TREF(transform) = TRUE;
TREF(no_spangbls) = TRUE; /* dse operates on a per-region basis irrespective of global mapping in gld */
TREF(skip_file_corrupt_check) = TRUE; /* do not let csd->file_corrupt flag cause errors in dse */
op_open_ptr = op_open;
patch_curr_blk = get_dir_root();
err_init(util_base_ch);
UNICODE_ONLY(gtm_strToTitle_ptr = >m_strToTitle);
GTM_ICU_INIT_IF_NEEDED; /* Note: should be invoked after err_init (since it may error out) and before CLI parsing */
sig_init(generic_signal_handler, dse_ctrlc_handler, suspsigs_handler, continue_handler);
atexit(util_exit_handler);
SET_LATCH_GLOBAL(&defer_latch, LOCK_AVAILABLE);
stp_init(STP_INITSIZE);
rts_stringpool = stringpool;
getjobname();
INVOKE_INIT_SECSHR_ADDRS;
io_init(TRUE);
getzdir();
gtm_chk_dist(argv[0]);
prealloc_gt_timers();
gt_timers_add_safe_hndlrs();
initialize_pattern_table();
gvinit();
region_init(FALSE);
util_out_print("!/File !_!AD", TRUE, DB_LEN_STR(gv_cur_region));
util_out_print("Region!_!AD!/", TRUE, REG_LEN_STR(gv_cur_region));
cli_lex_setup(argc, argv);
/* Since DSE operates on a region-by-region basis (for the most part), do not use a global directory at all from now on */
original_header = gd_header;
gd_header = NULL;
OPERATOR_LOG_MSG;
# ifdef DEBUG
if ((gtm_white_box_test_case_enabled && (WBTEST_SEMTOOLONG_STACK_TRACE == gtm_white_box_test_case_number) ))
{
sgmnt_addrs * csa;
node_local_ptr_t cnl;
csa = &FILE_INFO(gv_cur_region)->s_addrs;
cnl = csa->nl;
cnl->wbox_test_seq_num = 1; /*Signal the first step and wait here*/
/* The signal to the shell. MUPIP must not start BEFORE DSE */
util_out_print("DSE is ready. MUPIP can start. Note: This message is a part of WBTEST_SEMTOOLONG_STACK_TRACE test. "
"It will not appear in PRO version.", TRUE);
while (2 != cnl->wbox_test_seq_num) /*Wait for another process to get hold of the semaphore and signal next step*/
LONG_SLEEP(1);
}
# endif
if (argc < 2)
display_prompt();
while (1)
{
if (!dse_process(argc))
break;
display_prompt();
}
dse_exit();
REVERT;
return 0;
}
gtcm_server()
{
static readonly int4 reptim[2] = {-100000, -1}; /* 10ms */
static readonly int4 wait[2] = {-1000000, -1}; /* 100ms */
void gtcm_ch(), gtcm_exi_handler(), gtcm_init_ast(), gtcm_int_unpack(), gtcm_mbxread_ast(),
gtcm_neterr(), gtcm_read_ast(), gtcm_remove_from_action_queue(), gtcm_shutdown_ast(), gtcm_write_ast(),
la_freedb();
bool gtcm_link_accept();
bool alid;
char buff[512];
char *h = NULL;
char *la_getdb();
char nbuff[256];
char *pak = NULL;
char reply;
unsigned short outlen;
int4 closewait[2] = {0, -1};
int4 inid = 0, mdl = 0, nid = 0, days = 0;
int4 lic_status;
int4 lic_x;
int4 lm_mdl_nid();
uint4 status;
int i, receive(), value;
mstr name1, name2;
struct NTD *cmu_ntdroot();
connection_struct *prev_curr_entry;
struct dsc$descriptor_s dprd;
struct dsc$descriptor_s dver;
$DESCRIPTOR(node_name, nbuff);
$DESCRIPTOR(proc_name, "GTCM_SERVER");
$DESCRIPTOR(timout, buff);
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
assert(0 == EMPTY_QUEUE); /* check so dont need gdsfhead everywhere */
common_startup_init(GTCM_GNP_SERVER_IMAGE); /* Side-effect: Sets skip_dbtriggers to TRUE for non-trigger platforms */
gtm_env_init(); /* read in all environment variables */
name1.addr = "GTCMSVRNAM";
name1.len = SIZEOF("GTCMSVRNAM") - 1;
status = trans_log_name(&name1, &name2, nbuff);
if (SS$_NORMAL == status)
{
proc_name.dsc$a_pointer = nbuff;
proc_name.dsc$w_length = node_name.dsc$w_length = name2.len;
} else if (SS$_NOLOGNAM == status)
{
MEMCPY_LIT(nbuff, "GTCMSVR");
node_name.dsc$w_length = SIZEOF("GTCMSVR") - 1;
} else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) status);
sys$setprn(&proc_name);
status = lib$get_foreign(&timout, 0, &outlen, 0);
if ((status & 1) && (6 > outlen))
{
for (i = 0; i < outlen; i++)
{
value = value * 10;
if (buff[i] <= '9' && buff[i] >= '0')
value += buff[i] - 48;
else
break;
}
if (outlen && (i == outlen))
{
cm_timeout = TRUE;
closewait[0] = value * -10000000;
}
}
dprd.dsc$w_length = cm_prd_len;
dprd.dsc$b_dtype = DSC$K_DTYPE_T;
dprd.dsc$b_class = DSC$K_CLASS_S;
dprd.dsc$a_pointer= cm_prd_name;
dver.dsc$w_length = cm_ver_len;
dver.dsc$b_dtype = DSC$K_DTYPE_T;
dver.dsc$b_class = DSC$K_CLASS_S;
dver.dsc$a_pointer= cm_ver_name;
ast_init();
licensed = TRUE;
lkid = 2;
# ifdef NOLICENSE
lid = 1;
# else
/* this code used to be scattered to discourage reverse engineering, but since it now disabled, that seems pointless */
lic_status = ((NULL == (h = la_getdb(LMDB))) ? LP_NOCNFDB : SS$_NORMAL);
lic_status = ((1 == (lic_status & 1)) ? lm_mdl_nid(&mdl, &nid, &inid) : lic_status);
lic_status = ((1 == (lic_status & 1)) ? lp_licensed(h, &dprd, &dver, mdl, nid, &lid, &lic_x, &days, pak) : lic_status);
if (LP_NOCNFDB != lic_status)
la_freedb(h);
if (1 == (lic_status & 1))
{
licensed = TRUE;
if (days < 14)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_WILLEXPIRE);
} else
{
licensed = FALSE;
sys$exit(lic_status);
}
# endif
gtcm_ast_avail = astq_dyn_avail - GTCM_AST_OVRHD;
stp_init(STP_INITSIZE);
rts_stringpool = stringpool;
cache_init();
procnum = 0;
get_proc_info(0, TADR(login_time), &image_count);
memset(proc_to_clb, 0, SIZEOF(proc_to_clb));
status = cmi_init(&node_name, 0, 0, gtcm_init_ast, gtcm_link_accept);
if (!(status & 1))
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ((status ^ 3) | 4));
sys$exit(status);
}
ntd_root = cmu_ntdroot();
ntd_root->mbx_ast = gtcm_mbxread_ast;
ntd_root->err = gtcm_neterr;
gtcm_connection = FALSE;
lib$establish(gtcm_ch);
gtcm_exi_blk.exit_hand = >cm_exi_handler;
gtcm_exi_blk.arg_cnt = 1;
gtcm_exi_blk.cond_val = >cm_exi_condition;
sys$dclexh(>cm_exi_blk);
INVOKE_INIT_SECSHR_ADDRS;
initialize_pattern_table();
assert(run_time); /* Should have been set by common_startup_init */
while (!cm_shutdown)
{
if (blkdlist)
gtcml_chkreg();
assert(!lib$ast_in_prog());
status = sys$dclast(>cm_remove_from_action_queue, 0, 0);
if (SS$_NORMAL != status)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) CMERR_CMSYSSRV, 0, status, 0);
if (INTERLOCK_FAIL == curr_entry)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) CMERR_CMINTQUE);
if (EMPTY_QUEUE != curr_entry)
{
switch (*curr_entry->clb_ptr->mbf)
{
case CMMS_L_LKCANALL:
reply = gtcmtr_lkcanall();
break;
case CMMS_L_LKCANCEL:
reply = gtcmtr_lkcancel();
break;
case CMMS_L_LKREQIMMED:
reply = gtcmtr_lkreqimmed();
break;
case CMMS_L_LKREQNODE:
reply = gtcmtr_lkreqnode();
break;
case CMMS_L_LKREQUEST:
reply = gtcmtr_lkrequest();
break;
case CMMS_L_LKRESUME:
reply = gtcmtr_lkresume();
break;
case CMMS_L_LKACQUIRE:
reply = gtcmtr_lkacquire();
break;
case CMMS_L_LKSUSPEND:
reply = gtcmtr_lksuspend();
break;
case CMMS_L_LKDELETE:
reply = gtcmtr_lkdelete();
break;
case CMMS_Q_DATA:
reply = gtcmtr_data();
break;
case CMMS_Q_GET:
reply = gtcmtr_get();
break;
case CMMS_Q_KILL:
reply = gtcmtr_kill();
break;
case CMMS_Q_ORDER:
reply = gtcmtr_order();
break;
case CMMS_Q_PREV:
reply = gtcmtr_zprevious();
break;
case CMMS_Q_PUT:
reply = gtcmtr_put();
break;
case CMMS_Q_QUERY:
reply = gtcmtr_query();
break;
case CMMS_Q_ZWITHDRAW:
reply = gtcmtr_zwithdraw();
break;
case CMMS_S_INITPROC:
reply = gtcmtr_initproc();
break;
case CMMS_S_INITREG:
reply = gtcmtr_initreg();
break;
case CMMS_S_TERMINATE:
reply = gtcmtr_terminate(TRUE);
break;
case CMMS_E_TERMINATE:
reply = gtcmtr_terminate(FALSE);
break;
case CMMS_U_LKEDELETE:
reply = gtcmtr_lke_clearrep(curr_entry->clb_ptr, curr_entry->clb_ptr->mbf);
break;
case CMMS_U_LKESHOW:
reply = gtcmtr_lke_showrep(curr_entry->clb_ptr, curr_entry->clb_ptr->mbf);
break;
case CMMS_B_BUFRESIZE:
reply = CM_WRITE;
value = *(unsigned short *)(curr_entry->clb_ptr->mbf + 1);
if (value > curr_entry->clb_ptr->mbl)
{
free(curr_entry->clb_ptr->mbf);
curr_entry->clb_ptr->mbf = malloc(value);
}
*curr_entry->clb_ptr->mbf = CMMS_C_BUFRESIZE;
curr_entry->clb_ptr->mbl = value;
curr_entry->clb_ptr->cbl = 1;
break;
case CMMS_B_BUFFLUSH:
reply = gtcmtr_bufflush();
break;
case CMMS_Q_INCREMENT:
reply = gtcmtr_increment();
break;
default:
reply = FALSE;
if (SS$_NORMAL == status)
rts_error_csa(CSA_ARG(NULL)
VARLSTCNT(3) ERR_BADGTMNETMSG, 1, (int)*curr_entry->clb_ptr->mbf);
break;
}
if (curr_entry) /* curr_entry can be NULL if went through gtcmtr_terminate */
{
status = sys$gettim(&curr_entry->lastact[0]);
if (SS$_NORMAL != status)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) status);
/* curr_entry is used by gtcm_mbxread_ast to determine if it needs to defer the interrupt message */
prev_curr_entry = curr_entry;
if (CM_WRITE == reply)
{ /* if ast == gtcm_write_ast, let it worry */
curr_entry->clb_ptr->ast = gtcm_write_ast;
curr_entry = EMPTY_QUEUE;
cmi_write(prev_curr_entry->clb_ptr);
} else
{
curr_entry = EMPTY_QUEUE;
if (1 == (prev_curr_entry->int_cancel.laflag & 1))
{ /* valid interrupt cancel msg, handle in gtcm_mbxread_ast */
status = sys$dclast(gtcm_int_unpack, prev_curr_entry, 0);
if (SS$_NORMAL != status)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) status);
} else if (CM_READ == reply)
{
prev_curr_entry->clb_ptr->ast = gtcm_read_ast;
cmi_read(prev_curr_entry->clb_ptr);
}
}
}
} else if (1 < astq_dyn_avail)
{
# ifdef GTCM_REPTIM
/* if reptim is not needed - and smw doesn't know why it would be - remove this */
status = sys$schdwk(0, 0, &wait[0], &reptim[0]);
# else
status = sys$schdwk(0, 0, &wait[0], 0);
# endif
sys$hiber();
sys$canwak(0, 0);
}
if (cm_timeout && (0 == gtcm_users))
sys$setimr(efn_ignore, closewait, gtcm_shutdown_ast, &cm_shutdown, 0);
}
}