/* 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[].
*/
int main(int argc, char_ptr_t argv[])
{
omi_conn_ll conns;
bool set_pset();
int ret_val;
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
ctxt = NULL;
common_startup_init(GTCM_SERVER_IMAGE);
SPRINTF(image_id,"%s=gtcm_server", image_id);
# ifdef SEQUOIA
if (!set_pset())
exit(-1);
# endif
/* Initialize everything but the network */
err_init(gtcm_exit_ch);
gtm_chk_dist(argv[0]);
omi_errno = OMI_ER_NO_ERROR;
ctxt = ctxt;
ESTABLISH_RET(omi_dbms_ch, -1); /* any return value to signify error return */
gtcm_init(argc, argv);
gtcm_ltime = gtcm_stime = (int4)time(0);
# ifdef GTCM_RC
rc_create_cpt();
# endif
REVERT;
if (OMI_ER_NO_ERROR != omi_errno)
exit(omi_errno);
/* Initialize the network interface */
if (0 != (ret_val = gtcm_bgn_net(&conns))) /* Warning - assignment */
{
gtcm_rep_err("Error initializing TCP", ret_val);
gtcm_exi_condition = ret_val;
gtcm_exit();
}
SPRINTF(image_id,"%s(pid=%d) %s %s %s -id %d -service %s",
image_id,
omi_pid,
( history ? "-hist" : "" ),
( authenticate ? "-auth" : "" ),
( ping_keepalive ? "-ping" : "" ),
rc_server_id,
omi_service
);
OPERATOR_LOG_MSG;
omi_conns = &conns;
/* Should be forever, unless an error occurs */
gtcm_loop(&conns);
/* Clean up */
gtcm_end_net(&conns);
gtcm_exit();
return 0;
}
/*
* This routine is used to start a previously powered off processor.
* Note that restarted cpus are initialized into the offline state.
*/
void
restart_other_cpu(int cpuid)
{
struct cpu *cp;
kthread_id_t tp;
caddr_t sp;
extern void idle();
ASSERT(MUTEX_HELD(&cpu_lock));
ASSERT(cpuid < NCPU && cpu[cpuid] != NULL);
/*
* Obtain pointer to the appropriate cpu structure.
*/
cp = cpu[cpuid];
common_startup_init(cp, cpuid);
/*
* idle thread t_lock is held when the idle thread is suspended.
* Manually unlock the t_lock of idle loop so that we can resume
* the suspended idle thread.
* Also adjust the PC of idle thread for re-retry.
*/
cp->cpu_intr_actv = 0; /* clear the value from previous life */
cp->cpu_m.mutex_ready = 0; /* we are not ready yet */
lock_clear(&cp->cpu_idle_thread->t_lock);
tp = cp->cpu_idle_thread;
sp = tp->t_stk;
tp->t_sp = (uintptr_t)((struct rwindow *)sp - 1) - STACK_BIAS;
tp->t_pc = (uintptr_t)idle - 8;
/*
* restart the cpu now
*/
promsafe_pause_cpus();
start_cpu(cpuid, warm_flag_set);
start_cpus();
/* call cmn_err outside pause_cpus/start_cpus to avoid deadlock */
cmn_err(CE_CONT, "!cpu%d initialization complete - restarted\n",
cpuid);
}
int main (int argc, char **argv)
{
int res;
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
common_startup_init(MUPIP_IMAGE);
invocation_mode = MUMPS_UTILTRIGR;
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, NULL, suspsigs_handler, continue_handler); /* Note: no ^C handler is defined (yet) */
atexit(mupip_exit_handler);
licensed = TRUE;
in_backup = FALSE;
op_open_ptr = mu_op_open;
mu_get_term_characterstics();
gtm_chk_dist(argv[0]);
cli_lex_setup(argc,argv);
if (argc < 2) /* Interactive mode */
display_prompt();
/* this call should be after cli_lex_setup() due to S390 A/E conversion */
init_gtm();
while (TRUE)
{ func = 0;
if ((res = parse_cmd()) == EOF)
break;
else if (res)
{
if (1 < argc)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) res, 2, LEN_AND_STR(cli_err_str));
else
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(4) res, 2, LEN_AND_STR(cli_err_str));
}
if (func)
func();
if (argc > 1) /* Non-interactive mode, exit after command */
break;
display_prompt();
}
mupip_exit(SS_NORMAL);
return 0;
}
/*ARGSUSED*/
void
start_other_cpus(int flag)
{
int cpuid;
extern void idlestop_init(void);
int bootcpu;
/*
* Check if cpu_bringup_set has been explicitly set before
* initializing it.
*/
if (CPUSET_ISNULL(cpu_bringup_set)) {
CPUSET_ALL(cpu_bringup_set);
}
if (&cpu_feature_init)
cpu_feature_init();
/*
* Initialize CPC.
*/
kcpc_hw_init();
mutex_enter(&cpu_lock);
/*
* Initialize our own cpu_info.
*/
init_cpu_info(CPU);
/*
* Initialize CPU 0 cpu module private data area, including scrubber.
*/
cpu_init_private(CPU);
populate_idstr(CPU);
/*
* perform such initialization as is needed
* to be able to take CPUs on- and off-line.
*/
cpu_pause_init();
xc_init(); /* initialize processor crosscalls */
idlestop_init();
if (!use_mp) {
mutex_exit(&cpu_lock);
cmn_err(CE_CONT, "?***** Not in MP mode\n");
return;
}
/*
* should we be initializing this cpu?
*/
bootcpu = getprocessorid();
/*
* launch all the slave cpus now
*/
for (cpuid = 0; cpuid < NCPU; cpuid++) {
pnode_t nodeid = cpunodes[cpuid].nodeid;
if (nodeid == (pnode_t)0)
continue;
if (cpuid == bootcpu) {
if (!CPU_IN_SET(cpu_bringup_set, cpuid)) {
cmn_err(CE_WARN, "boot cpu not a member "
"of cpu_bringup_set, adding it");
CPUSET_ADD(cpu_bringup_set, cpuid);
}
continue;
}
if (!CPU_IN_SET(cpu_bringup_set, cpuid))
continue;
ASSERT(cpu[cpuid] == NULL);
if (setup_cpu_common(cpuid)) {
cmn_err(CE_PANIC, "cpu%d: setup failed", cpuid);
}
common_startup_init(cpu[cpuid], cpuid);
start_cpu(cpuid, cold_flag_set);
/*
* Because slave_startup() gets fired off after init()
* starts, we can't use the '?' trick to do 'boot -v'
* printing - so we always direct the 'cpu .. online'
* messages to the log.
*/
cmn_err(CE_CONT, "!cpu%d initialization complete - online\n",
cpuid);
cpu_state_change_notify(cpuid, CPU_SETUP);
if (dtrace_cpu_init != NULL)
(*dtrace_cpu_init)(cpuid);
}
/*
* since all the cpus are online now, redistribute interrupts to them.
*/
intr_redist_all_cpus();
mutex_exit(&cpu_lock);
/*
* Start the Ecache scrubber. Must be done after all calls to
* cpu_init_private for every cpu (including CPU 0).
*/
cpu_init_cache_scrub();
if (&cpu_mp_init)
cpu_mp_init();
}
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;
}
int gtm_main (int argc, char **argv, char **envp)
#ifdef __osf__
# pragma pointer_size (restore)
#endif
{
char *ptr, *eq, **p;
int eof, parse_ret;
int gtmcrypt_errno;
# ifdef GTM_SOCKET_SSL_SUPPORT
int status;
char tlsid_env_name[MAX_TLSID_LEN * 2];
# endif
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
gtmenvp = envp;
gtm_dist_ok_to_use = TRUE;
common_startup_init(GTM_IMAGE);
GTMTRIG_DBG_ONLY(ch_at_trigger_init = &mdb_condition_handler);
err_init(stop_image_conditional_core);
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 */
cli_lex_setup(argc, argv);
/* put the arguments into buffer, then clean up the token buffer
* cli_gettoken() copies all arguments except the first one argv[0]
* into the buffer (cli_lex_in_ptr->in_str).
* i.e. command line: "/usr/library/V990/mumps -run somefile"
* the buffer cli_lex_in_ptr->in_str == "-run somefile"
*/
if (1 < argc)
cli_gettoken(&eof);
/* cli_gettoken() extracts the first token into cli_token_buf (in tok_extract())
* which should be done in parse_cmd(), So, reset the token buffer here to make
* parse_cmd() starts from the first token
*/
cli_token_buf[0] = '\0';
/* insert the "MUMPS " in the parsing buffer the buffer is now:
* cli_lex_in_ptr->in_str == "MUMPS -run somefile"
* we didnot change argv[0]
*/
ptr = cli_lex_in_ptr->in_str;
memmove(strlen("MUMPS ") + ptr, ptr, strlen(ptr) + 1); /* BYPASSOK */
MEMCPY_LIT(ptr, "MUMPS ");
/* reset the argument buffer pointer, it's changed in cli_gettoken() call above
* do NOT reset to 0(NULL) to avoid fetching cmd line args into buffer again
* cli_lex_in_ptr->tp is the pointer to indicate current position in the buffer
* cli_lex_in_ptr->in_str
*/
cli_lex_in_ptr->tp = cli_lex_in_ptr->in_str;
parse_ret = parse_cmd();
if (parse_ret && (EOF != parse_ret))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) parse_ret, 2, LEN_AND_STR(cli_err_str));
if (cli_present("DIRECT_MODE"))
invocation_mode = MUMPS_DIRECT;
else if (cli_present("RUN"))
invocation_mode = MUMPS_RUN;
gtm_chk_dist(argv[0]);
/* this should be after cli_lex_setup() due to S390 A/E conversion in cli_lex_setup */
init_gtm();
# ifdef GTM_TLS
if (MUMPS_COMPILE != invocation_mode)
{
if ((NULL != (ptr = (char *)getenv(GTM_PASSWD_ENV))) && (0 == strlen(ptr)))
{
INIT_PROC_ENCRYPTION(NULL, gtmcrypt_errno);
if (0 != gtmcrypt_errno)
{
CLEAR_CRYPTERR_MASK(gtmcrypt_errno);
assert(!IS_REPEAT_MSG_MASK(gtmcrypt_errno));
assert((ERR_CRYPTDLNOOPEN == gtmcrypt_errno) || (ERR_CRYPTINIT == gtmcrypt_errno));
if (ERR_CRYPTDLNOOPEN == gtmcrypt_errno)
gtmcrypt_errno = ERR_CRYPTDLNOOPEN2;
else if (ERR_CRYPTINIT == gtmcrypt_errno)
gtmcrypt_errno = ERR_CRYPTINIT2;
gtmcrypt_errno = SET_CRYPTERR_MASK(gtmcrypt_errno);
GTMCRYPT_REPORT_ERROR(gtmcrypt_errno, rts_error, SIZEOF(GTMCRYPT_ERRLIT) - 1, GTMCRYPT_ERRLIT); /* BYPASSOK */
}
}
# ifdef GTM_SOCKET_SSL_SUPPORT
/* The below logic is for prefetching the password for TLS identifiers that may have been set in the environment.
* But, since SSL support for Socket devices is not yet implemented, this logic need not be enabled as of this
* writing. When SSL support for socket devices is implemented, the surrounding #ifdef can be removed.
*/
if (NULL != getenv("gtmcrypt_config"))
{ /* Environment is configured for SSL/TLS (and/or encryption). Check if any environment variable of the form
* `gtmtls_passwd_*' is set to NULL string. If so, nudge the SSL/TLS library to read password(s) from the
* user.
*/
for (p = envp; *p; p++)
{
ptr = *p;
if (0 == MEMCMP_LIT(ptr, GTMTLS_PASSWD_ENV_PREFIX))
{ /* At least one environment variable of $gtmtls_passwd_* is found. */
eq = strchr(ptr, '=');
if (0 != strlen(eq + 1))
break; /* Set to non-empty string. No need to initialize the library now. */
/* Set to empty string. */
if (NULL == tls_ctx)
{
if (SS_NORMAL != (status = gtm_tls_loadlibrary()))
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_TLSDLLNOOPEN, 0,
ERR_TEXT, 2, LEN_AND_STR(dl_err));
}
if (NULL == (tls_ctx = gtm_tls_init(GTM_TLS_API_VERSION,
GTMTLS_OP_INTERACTIVE_MODE)))
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_TLSINIT, 0,
ERR_TEXT, 2, LEN_AND_STR(gtm_tls_get_error()));
}
}
assert(NULL != tls_ctx);
assert((MAX_TLSID_LEN * 2) > (int)(eq - ptr));
memcpy(tlsid_env_name, ptr, (int)(eq - ptr));
tlsid_env_name[(int)(eq - ptr)] = '\0';
gtm_tls_prefetch_passwd(tls_ctx, tlsid_env_name);
}
}
}
# endif
}
# endif
dm_start();
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);
}
}
