void Time2Chars (double dSecond, char* buffer)
{
char* p;
char buff1[16];
char buff2[16];
int m = 0;
int h = 0;
while (dSecond >= 60.0)
{
dSecond -= 60.0;
m++;
}
while (m >= 60)
{
m -= 60;
h++;
}
dSecond = dSecond*100;
STprintf(buff1, "%04d", (int)dSecond);
STlcopy (buff1, buff2, 2);
p = buff1;
p += 2;
STprintf (buffer, "%02d%:%02d:%s", h, m, buff2);
STcat(buffer, ".");
STcat(buffer, p);
}
/*
** Name: CS_cp_mbx_create - mailbox creation and initialization
**
** Description:
** This subroutine is called from CSinitiate().
**
** It does the following:
** a) establishes a mailbox, with the name II_CPRES_xx_pid, where
** xx is the (optional) installation code, and pid is the
** process ID in hex.
** b) queues a read on the mailbox, with completion routine set to
** CS_cp_mbx_complete
** c) deletes the mailbox, so it'll go away when the process dies.
**
** Inputs:
** num_sessions - Number of sessions for the process.
**
** Outputs:
** sys_err - reason for error
**
** Returns:
** OK, !OK
**
** Side Effects:
** Sets cpres_mbx_chan to the mailbox's channel
** Defines the system-wide logical name II_CPRES_xx_pid
**
** History:
** Summer, 1992 (bryanp)
** Working on the new portable logging and locking system.
** 08-Nov-2007 (jonj)
** Use of "num_sessions" is totally bogus. CS_cp_mbx_create() is called
** before the startup parms are determined from config.dat (where we'd
** find "connect_limit"), so SCD hard-codes num_sessions = 32, resulting
** in CS_CP_MIN_MSGS == 5 always being used, which is way too small.
** Instead, default to the (configurable) VMS sysgen parameter
** DEFMBXBUFQUO.
** Also, create mailbox as read-only. Writers will assign write-only
** channels.
*/
STATUS
CS_cp_mbx_create(i4 num_sessions, CL_ERR_DESC *sys_err)
{
struct dsc$descriptor_s name_desc;
i4 vms_status;
char mbx_name[100];
char *inst_id;
PID pid;
CL_CLEAR_ERR(sys_err);
/*
** Build the mailbox logical name:
*/
PCpid(&pid);
NMgtAt("II_INSTALLATION", &inst_id);
if (inst_id && *inst_id)
STprintf(mbx_name, "II_CPRES_%s_%x", inst_id, (i4)pid);
else
STprintf(mbx_name, "II_CPRES_%x", (i4)pid);
name_desc.dsc$a_pointer = mbx_name;
name_desc.dsc$w_length = STlength(mbx_name);
name_desc.dsc$b_dtype = DSC$K_DTYPE_T;
name_desc.dsc$b_class = DSC$K_CLASS_S;
vms_status = sys$crembx(
1, /* Mailbox is "permanent" */
&cpres_mbx_chan, /* where to put channel */
(i4)sizeof(CS_CP_WAKEUP_MSG),
/* maximum message size */
0, /* buffer quota (DEFMBXBUFQUO) */
0, /* prot mask = all priv */
PSL$C_USER, /* acmode */
&name_desc, /* logical name descriptor */
CMB$M_READONLY, /* flags */
0); /* nullarg */
if ( vms_status != SS$_NORMAL )
{
sys_err->error = vms_status;
if (vms_status == SS$_NOPRIV)
return (E_CS00F8_CSMBXCRE_NOPRIV);
else
return (E_CS00F7_CSMBXCRE_ERROR);
}
/* Hang a read */
cpres_q_read_io();
/* Mark for deletion, so it disappears when we exit. */
sys$delmbx(cpres_mbx_chan);
cpres_channels_sem = 0;
cpres_num_channels_assigned = 0;
return (OK);
}
DB_STATUS
qee_p1_dsh_gen(
QEF_RCB *v_qer_p,
QEE_DSH *i_dsh_p)
{
DB_STATUS status = E_DB_OK;
QEF_QP_CB *qp_p = i_dsh_p->dsh_qp_ptr; /* debugging aid */
QEE_DDB_CB *dde_p = i_dsh_p->dsh_ddb_cb;
char cur_name[DB_CURSOR_MAXNAME + 1];
char *cbuf = v_qer_p->qef_cb->qef_trfmt;
i4 cbufsize = v_qer_p->qef_cb->qef_trsize;
qed_u0_trimtail(i_dsh_p->dsh_qp_id.db_cur_name, DB_CURSOR_MAXNAME, cur_name);
STprintf(cbuf,
"%s %p: ... query id: %x %x %s\n",
IIQE_61_qefsess,
(PTR) v_qer_p->qef_cb,
i_dsh_p->dsh_qp_id.db_cursor_id[0],
i_dsh_p->dsh_qp_id.db_cursor_id[1],
cur_name);
qec_tprintf(v_qer_p, cbufsize, cbuf);
if (i_dsh_p->dsh_qp_status & DSH_QP_LOCKED)
{
STprintf(cbuf,
"%s %p: ... query plan LOCKED by this session\n",
IIQE_61_qefsess,
(PTR) v_qer_p->qef_cb);
qec_tprintf(v_qer_p, cbufsize, cbuf);
}
if (i_dsh_p->dsh_qp_status & DSH_QP_OBSOLETE)
{
STprintf(cbuf,
"%s %p: ... query plan is OBSOLETE; to be destroyed\n",
IIQE_61_qefsess,
(PTR) v_qer_p->qef_cb);
qec_tprintf(v_qer_p, cbufsize, cbuf);
}
if (i_dsh_p->dsh_qp_status & DSH_DEFERRED_CURSOR)
{
STprintf(cbuf,
"%s %p: ... query plan contains a DEFERRED cursor\n",
IIQE_61_qefsess,
(PTR) v_qer_p->qef_cb);
qec_tprintf(v_qer_p, cbufsize, cbuf);
}
if (i_dsh_p->dsh_positioned)
{
STprintf(cbuf,
"%s %p: ... cursor is positioned\n",
IIQE_61_qefsess,
(PTR) v_qer_p->qef_cb);
qec_tprintf(v_qer_p, cbufsize, cbuf);
}
return(E_DB_OK);
}
bool
ask_for_conditional(WINDOW *askW,char edCAns)
{
char cond_exp ;
cond_exp = EOS;
if (conditional_str == NULL)
conditional_str = SEP_MEalloc(SEP_ME_TAG_NODEL, TEST_LINE+1, TRUE,
(STATUS *) NULL);
if (conditional_old == NULL)
conditional_old = SEP_MEalloc(SEP_ME_TAG_NODEL, TEST_LINE+1, TRUE,
(STATUS *) NULL);
if (conditional_prompt == NULL)
conditional_prompt = SEP_MEalloc(SEP_ME_TAG_NODEL, TEST_LINE+1, TRUE,
(STATUS *) NULL);
if ((*conditional_str == EOS) && (SEP_IF_EXPRESSION != NULL) &&
(*SEP_IF_EXPRESSION != EOS))
STcopy(SEP_IF_EXPRESSION, conditional_str);
STcopy(conditional_str, conditional_old);
#ifdef NT_GENERIC
STprintf(conditional_prompt,ERx(" IF (%s) >"),conditional_str);
#else
STprintf(conditional_prompt,ERx("%s%s%s%s%s IF (%s) >%s"),REG_CHAR,
ATTR_OFF, PROMPT_POS, DEL_EOL, REV_VIDEO, conditional_str,
ATTR_OFF);
#endif
if (edCAns == EOS)
get_string(askW, conditional_prompt, conditional_str);
if ((conditional_str == NULL) || (*conditional_str == EOS))
{
if (*conditional_old == EOS)
{
if (edCAns == EOS)
put_message(askW,
ERx("No conditional expression for this Canon."));
return (FALSE);
}
else
{
STcopy(conditional_old, conditional_str);
}
}
else if (STskipblank(conditional_str, STlength(conditional_str)) == NULL)
{
*conditional_str = EOS;
*conditional_old = EOS;
if (edCAns == EOS)
put_message(askW, ERx("No conditional expression for this Canon."));
return (FALSE);
}
STpolycat(3, ERx(" IF ("), conditional_str, ERx(") "), conditional_prompt);
return (TRUE);
}
DB_STATUS
qee_p4_ldb_qid(
QEF_RCB *v_qer_p,
QEE_DSH *i_dsh_p)
{
/*
DB_STATUS status = E_DB_OK;
QES_DDB_SES *dds_p = & v_qer_p->qef_cb->qef_c2_ddb_ses;
QEF_DDB_REQ *ddr_p = & v_qer_p->qef_r3_ddb_req;
*/
QEE_DDB_CB *qee_p = i_dsh_p->dsh_ddb_cb;
DB_CURSOR_ID *ldb_qid_p = & qee_p->qee_d5_local_qid;
char cur_name[DB_CURSOR_MAXNAME + 1];
char *cbuf = v_qer_p->qef_cb->qef_trfmt;
i4 cbufsize = v_qer_p->qef_cb->qef_trsize;
STprintf(cbuf,
"%s %p: ...the LDB query id:\n",
IIQE_61_qefsess,
(PTR) v_qer_p->qef_cb);
qec_tprintf(v_qer_p, cbufsize, cbuf);
STprintf(cbuf,
"%s %p: ... 1) DB_CURSOR_ID[0] %x,\n",
IIQE_61_qefsess,
(PTR) v_qer_p->qef_cb,
ldb_qid_p->db_cursor_id[0]);
qec_tprintf(v_qer_p, cbufsize, cbuf);
STprintf(cbuf,
"%s %p: ... 2) DB_CURSOR_ID[1] %x,\n",
IIQE_61_qefsess,
(PTR) v_qer_p->qef_cb,
ldb_qid_p->db_cursor_id[1]);
qec_tprintf(v_qer_p, cbufsize, cbuf);
qed_u0_trimtail(ldb_qid_p->db_cur_name, DB_CURSOR_MAXNAME, cur_name);
STprintf(cbuf,
"%s %p: ... 3) DB_CUR_NAME %s\n",
IIQE_61_qefsess,
(PTR) v_qer_p->qef_cb,
cur_name);
qec_tprintf(v_qer_p, cbufsize, cbuf);
return(E_DB_OK);
}
int odxa_errhandler(void)
{
char buf[257]="";
char message[513]=" ::[ , 00000000]: ";
long error_no = 0;
char error_text[257];
SYSTIME time_now;
i4 len;
// EXEC SQL INQUIRE_SQL(:error_no = ERRORNO,:error_text = ERRORTEXT);
IILQisInqSqlio((short *)0,1,30,4,&error_no,2);
IILQisInqSqlio((short *)0,1,32,256,error_text,63);
CVlx((u_i4)error_no, buf);
STprintf(message, ERx(" ::[%-16s, %s]: "), szFuncName, buf);
TMnow( &time_now );
TMstr( &time_now, buf );
STcat(message, buf);
STcat(message, " MS DTC Ingres XA Interface: ");
if (STequal(szFuncName,"xa_open")) /* dump out xa_open's xa_info string */
{
len = (i4)STlength(message);
STcat(message, errlog_xa_info);
WriteDTCerrToEventLog(S_OK, message);
message[len] = '\0'; /* chop back to the message header */
}
STcat(message, error_text);
WriteDTCerrToEventLog(S_OK, message);
return 0;
}
/*{
** Name: IIAG4fosFreeObjectStack - Free objects from the Known Obj stack
**
** Description:
** Pop the Known object stack back to the specified size, which must be
** non-negative and not more than the current stack size. This marks
** the objects as "unknown". Also, reference count information can
** be decremented in the previously known objects so that ABF run-time can
** potentially free up memory (this step is skipped for now).
**
** Inputs:
** reset_sp {nat} value to reset stackpointer to.
**
** Outputs:
** NONE.
**
** Returns:
** OK - object stack reset
** E_G42726_NO_INIT - stack was never initialized.
** E_G42728_BAD_STACK_POP - invalid stackpointer value (beyond current).
**
** History:
** 15-dec-92 (davel)
** Initial version.
*/
STATUS
IIAG4fosFreeObjectStack(i4 reset_sp)
{
G4ERRDEF g4errdef;
if (alloc_stacksize == 0)
{
g4errdef.errmsg = E_G42726_NO_INIT;
g4errdef.numargs = 0;
IIAG4semSetErrMsg(&g4errdef, TRUE);
return E_G42726_NO_INIT;
}
else if (reset_sp < 0 || reset_sp > stackpointer)
{
/* this should never happen. Show the current and reset stackpointers
** in the error message.
*/
char buf[64];
g4errdef.errmsg = E_G42728_BAD_STACK_POP;
g4errdef.numargs = 1;
STprintf(buf, "%d -> %d", stackpointer, reset_sp);
g4errdef.args[0] = (PTR)buf;
IIAG4semSetErrMsg(&g4errdef, TRUE);
return E_G42728_BAD_STACK_POP;
}
else
{
/* XXX just reset the stack for now; no reference count decrementing */
stackpointer = reset_sp;
return OK;
}
}
STATUS
append_line(char *aline,i4 newline)
{
char buffer [TEST_LINE+5] ;
char *cp = aline ;
/*
line is printed long enough to accomodate SCR output
*/
/*
This loop breaks up long lines and puts the continuation character
at the TEST_LINE+2 position.
*/
while (STlength(cp) > TEST_LINE+3)
{
STprintf(buffer, ERx("%.*s%s\n"), TEST_LINE+2, cp, cont_char);
SIputrec(buffer,logptr);
cp += TEST_LINE+2;
}
if (newline)
{
STpolycat(2,cp,ERx("\n"),buffer);
return(SIputrec(buffer,logptr));
}
else
return(SIputrec(cp,logptr));
}
/*{
** Name: MO_mon_id_get -- get method for monitor id.
**
** Description:
** A get method to make the monitor id visible.
**
** Re-entrancy:
** yes.
**
** Inputs:
** offset ignored
** objsize ignored
** object an MO_MON_BLOCK
** luserbuf length of out buf
**
** Outputs:
** userbuf out buf
**
** Returns:
** OK
** MO_VALUE_TRUNCATED
**
** Side Effects:
** May temporarily allocated some memory, freed before return.
**
** History:
** 24-sep-92 (daveb)
** documented
** 7-sep-93 (swm)
** call MOptrout() rather than MOulongout() for mp->mon_data to
** avoid i4/pointer truncation errors.
*/
STATUS
MO_mon_id_get(i4 offset,
i4 objsize,
PTR object,
i4 luserbuf,
char *userbuf)
{
STATUS ret_val = OK;
MO_MON_BLOCK *mp = (MO_MON_BLOCK *)object;
char localbuf[ MO_MAX_NUM_BUF * 3 + 2 ];
char numbuf[ MO_MAX_NUM_BUF ];
i4 len;
char *outbuf;
(void)MOptrout( 0, mp->mon_data, sizeof( numbuf ), numbuf );
len = (i4)(STlength( mp->mo_class->node.key ) + STlength(numbuf) + 2);
if( len <= sizeof( localbuf ) )
outbuf = localbuf;
else
outbuf = MO_alloc( len, &ret_val );
if( ret_val == OK )
{
STprintf( outbuf, "%s.%s", mp->mo_class->node.key, numbuf );
ret_val = MOstrout( MO_VALUE_TRUNCATED, outbuf, luserbuf, userbuf );
if( outbuf != localbuf )
MO_free( outbuf, len );
}
# if 0
if( ret_val != OK )
/* FIXME */
# endif
return( ret_val );
}
/*
** Name: scs_broadcast_mesg
**
** Description:
** Sends a broadcast message to a particular session
**
** The current implementation queues a TRACE message for the
** session, sent out during later communications.
**
** History:
** 15-dec-93 (robf)
** Created
**
*/
static STATUS
scs_broadcast_mesg(SCD_SCB *scb, PTR mesgptr)
{
char sendmesg[1024];
SCF_CB scf_cb;
char *m=(char*)mesgptr;
static char *broadcast_hdr =
"********************************************************************\nBroadcast message:\n\t";
DB_STATUS status;
if( scb != NULL && scb->cs_scb.cs_client_type == SCD_SCB_TYPE &&
(scb->scb_sscb.sscb_stype == SCS_SNORMAL ||
scb->scb_sscb.sscb_stype == SCS_SMONITOR ))
{
if(STlength(mesgptr)>sizeof(sendmesg)-sizeof(broadcast_hdr))
mesgptr[sizeof(sendmesg)-sizeof(broadcast_hdr)]= EOS;
/*
** Format broadcast
*/
STprintf(sendmesg,"%s%s", broadcast_hdr, m);
/*
** Send message to scc.
*/
scf_cb.scf_len_union.scf_blength=STlength(sendmesg);
scf_cb.scf_ptr_union.scf_buffer=sendmesg;
scf_cb.scf_session = (SCF_SESSION)scb;
status = scc_trace(&scf_cb, scb);
/* scc_trace already logs errors, so don't duplicate here */
}
return OK;
}
static char *
er_decode( STATUS msg_id )
{
STATUS old_err;
STATUS errstat;
CL_ERR_DESC err_code;
i4 ret_len;
char lbuf[ sizeof(ERbuf) ];
if( msg_id == OK )
{
errstat = OK;
STcopy( "OK", ERbuf );
}
else if ((errstat = ERslookup(msg_id, /* msg num */
NULL, /* input cl err */
0, /* flags */
(char *) NULL, /* sqlstate */
ERbuf, /* buf */
sizeof(ERbuf), /* sizeof buf */
-1, /* language */
&ret_len, /* msg len */
&err_code, /* output err */
0, /* num params */
NULL) /* params */
) != OK)
{
/* Recurse to decode ER error. If we were processing error
already, give up to halt recursion */
old_err = ERstat; /* OK first time in */
ERstat = errstat; /* now not OK second time through */
if( old_err == OK )
STcopy( lbuf, er_decode( errstat ) );
else
STprintf(ERbuf, "ER err 0x%x", errstat );
STprintf( ERbuf, "0x%x not found: %s", msg_id, lbuf );
}
/* Clear recursion check */
ERstat = OK;
return( ERbuf );
}
static void
display_err(char *etxt, STATUS status)
{
if (OK != ERreport(status, &etxt[STlength(etxt)]))
STprintf(&etxt[STlength(etxt)],
"(Reason unknown)", status);
SIprintf("%s\n",etxt);
}
/*{
** Name: ule_initiate - Provide server constant info for the server header
**
** Description:
** This routine takes in the server constant parameters SERVER NAME and
** NODE NAME, placing them in an area which is easily found to place on
** all error messages.
**
** Inputs:
** node_name Pointer to node name, which is
** l_node_name characters long
** server_name Same for server name
** l_server_name
**
** Outputs:
** None.
** Returns:
** VOID
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 06-Aug-1987 (fred)
** Created.
** 21-Mar-2005 (mutma03)
** cleanup of node translation code for clusters.
** 07-jan-2008 (joea)
** Undo 28-jun-2001 and 21-mar-2005 cluster nickname changes.
*/
VOID
ule_initiate( char *node_name, i4 l_node_name, char *server_name,
i4 l_server_name )
{
PID proc_id;
char fmt[20];
if (Ule_started <= 0)
{
PCpid(&proc_id);
MEfill(sizeof(ULE_MHDR), (u_char)' ', (PTR)&Ule_mhdr);
MEmove( l_node_name,
(PTR) node_name,
(char) ' ',
sizeof(Ule_mhdr.ule_node),
(PTR) &Ule_mhdr.ule_node[0]);
MEmove( l_server_name,
(PTR) server_name,
(char) ' ',
sizeof(Ule_mhdr.ule_server),
(PTR) &Ule_mhdr.ule_server[0]);
MEfill( sizeof(Ule_mhdr.ule_session),
(u_char) '*',
(PTR) &Ule_mhdr.ule_session[0]);
Ule_mhdr.ule_pad1[0] = ':',
Ule_mhdr.ule_pad1[1] = ':',
Ule_mhdr.ule_pad1[2] = '[';
Ule_mhdr.ule_pad2[0] = ',',
Ule_mhdr.ule_pad2[1] = ' ';
STprintf( fmt, "%s", PIDFMT );
STprintf(Ule_mhdr.ule_pid, fmt, proc_id);
Ule_mhdr.ule_pad3[0] = ',',
Ule_mhdr.ule_pad3[1] = ' ';
Ule_mhdr.ule_pad4[0] = ',';
Ule_mhdr.ule_pad4[1] = ' ';
MEfill( sizeof(Ule_mhdr.ule_source),
(char) ' ',
(PTR) &Ule_mhdr.ule_source[0]);
Ule_mhdr.ule_pad5[0] = ']',
Ule_mhdr.ule_pad5[1] = ':',
Ule_mhdr.ule_pad5[2] = ' ';
Ule_started = 1;
}
}
/*{
** Name: opx_rerror - this routine will report an optimizer error
**
** Description:
** This routine will log an optimizer error.
**
** Inputs:
** opfcb ptr to caller's control block
** error optimizer error code to log
**
** Outputs:
** Returns:
** VOID
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 3-jul-86 (seputis)
** initial creation
** 21-may-89 (jrb)
** now passes generic error to opx_sccerror
** 24-oct-92 (andre)
** interfaces of ule_format() and opx_sccerror() have been changed to
** receive (DB_SQLSTATE *)
** 24-june-03 (inkdo01)
** Add OP04C0 to list for which error is NOT returned to user.
** 22-june-06 (dougi)
** Make E_OP0018 (timeoutabort) go to log where the query text also
** gets dumped.
** 24-jun-08 (hayke02)
** Treat E_OP04C1 like E_OP04C0: soft failure, error reported to
** errlog.log and retry using non-greedy enumeration, unless op247 is
** set.
[@history_line@]...
*/
VOID
opx_rerror(
OPF_CB *opfcb,
OPX_ERROR error)
{
DB_STATUS ule_status; /* return status from ule_format */
i4 ule_error; /* ule cannot format message */
char msg_buffer[DB_ERR_SIZE]; /* error message buffer */
i4 msg_buf_length; /* length of message returned */
i4 log; /* should this error be logged */
DB_SQLSTATE sqlstate;
bool enumnomsg = FALSE;
opfcb->opf_errorblock.err_code = error; /* save error code */
if ((error % 256) < 128 && error != E_OP0018_TIMEOUTABORT)
log = ULE_LOOKUP;
else
log = ULE_LOG;
ule_status = ule_format( error, (CL_SYS_ERR *)NULL, log, &sqlstate,
msg_buffer, (i4) (sizeof(msg_buffer)-1), &msg_buf_length,
&ule_error, 0);
if (ule_status != E_DB_OK)
{
(VOID)STprintf(msg_buffer,
"ULE error = %x, Optimizer message cannot be found - error no. = %x\n",
ule_error, error );
}
else
msg_buffer[msg_buf_length] = 0; /* null terminate */
if ((error == E_OP04C0_NEWENUMFAILURE)
||
(error == E_OP04C1_GREEDYCONSISTENCY))
{
OPS_CB *opscb;
OPS_STATE *global;
i4 temp;
/* Check if new enumeration is result of tp op247 - if not,
** message isn't displayed. */
opscb = ops_getcb();
global = opscb->ops_state;
if (!global->ops_cb->ops_check ||
!opt_svtrace( global->ops_cb, OPT_F119_NEWENUM, &temp, &temp))
enumnomsg = TRUE;
}
if (error != E_OP0003_ASYNCABORT && !enumnomsg)
/* do not report control C errors
** or "new enumeration" errors
** to the user */
{
(VOID) opx_sccerror(E_DB_ERROR, &sqlstate, error, msg_buffer,
(i4)msg_buf_length);
}
}
VOID
history_time(char *timeStr)
{
SYSTIME atime ;
struct TMhuman htime ;
TMnow(&atime);
TMbreak(&atime, &htime);
STprintf(timeStr, ERx("%s-%s-%s"), htime.day, htime.month, htime.year);
}
VOID
copyright_year(char *year)
{
SYSTIME atime ;
struct TMhuman htime ;
TMnow(&atime);
TMbreak(&atime, &htime);
STprintf(year, ERx("%s"), htime.year);
}
static void
show( char *classid,
char *instance,
char *sval,
i4 perms,
PTR arg )
{
char classidbuf[ MAXCLASSID + MAXINSTANCE + 1 ];
STprintf( classidbuf, "%s:%s:", classid, instance );
SIprintf(classidbuf, "%-50s '%-12s'\t0%o\n", classidbuf, sval, perms );
}
STATUS
gcn_request( char *gcn_host, i4 *assoc_no, i4 *protocol )
{
GCA_RQ_PARMS request;
STATUS status = OK;
char tbuff[ GC_HOSTNAME_MAX + 12 ];
char *target;
i4 len;
/*
** Prepare for GCA_REQUEST service call
*/
len = (gcn_host ? STlength( gcn_host ) + 2 : 0) + 10;
target = (len <= sizeof( tbuff ))
? tbuff : (char *)MEreqmem( 0, len, FALSE, NULL );
if ( ! target ) return( E_GC0013_ASSFL_MEM );
STprintf( target, "%s%s/IINMSVR",
gcn_host ? gcn_host : "", gcn_host ? "::" : "" );
MEfill( sizeof( request ), '\0', (PTR)&request );
request.gca_peer_protocol = GCA_PROTOCOL_LEVEL_63;
request.gca_partner_name = target;
/*
** Make GCA_REQUEST service call
*/
gca_call( &gcn_gca_cb, GCA_REQUEST, (GCA_PARMLIST *)&request,
GCA_SYNC_FLAG, NULL, GCN_RCV_TIMEOUT, &status );
gcn_checkerr( "GCA_REQUEST",
&status, request.gca_status, &request.gca_os_status );
if ( status != OK ) goto done;
if ( gcn_host && request.gca_peer_protocol < GCA_PROTOCOL_LEVEL_50 )
{
gcn_release( request.gca_assoc_id );
CL_CLEAR_ERR( &request.gca_os_status );
gcn_checkerr( "GCA_REQUEST",
&status, E_GC000A_INT_PROT_LVL, &request.gca_os_status );
goto done;
}
*assoc_no = request.gca_assoc_id;
*protocol = request.gca_peer_protocol;
done :
if ( target != tbuff ) MEfree( (PTR)target );
return( status );
}
/*
** Name: sc0a_qrytext_data(), write query text parameters in one or more
** segments to the audit log.
**
** Description:
** This routine is an interface to SXF to write audit records
** from SCF.
**
** Inputs:
** scb SCB
**
** num_data Number of data elements
**
** qrydata query data to be audited
**
** Outputs:
** Returns:
** E_DB_OK
** E_DB_ERROR
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 6-jul-93 (robf)
** Created.
*/
DB_STATUS
sc0a_qrytext_data(
SCD_SCB *scb,
i4 num_data,
DB_DATA_VALUE **qrydata
)
{
i4 i;
DB_DATA_VALUE *dbv;
char namebuf[DB_MAXNAME+1];
DB_STATUS status=E_DB_OK;
if (!(Sc_main_cb->sc_capabilities & SC_C_C2SECURE))
{
/*
** This is not a C2 server so can just return
*/
return E_DB_OK;
}
if (!(scb->scb_sscb.sscb_facility & (1 << DB_SXF_ID)))
{
/*
** SXF not initialized yet so quietly return,
*/
return E_DB_OK;
}
if (!(scb->scb_sscb.sscb_ics.ics_rustat&DU_UAUDIT_QRYTEXT))
{
/*
** Session doesn't have query text auditing so don't audit
*/
return E_DB_OK;
}
/*
** Loop over all data items formatting as parameters
*/
for( i=0; i<num_data; i++)
{
dbv=qrydata[i];
STprintf(namebuf,"Param %d",i+1);
status=sc0a_qrytext_param(scb,
namebuf,
STlength(namebuf),
dbv);
if(status!=E_DB_OK)
break;
}
return status;
}
DB_STATUS
qee_p0_prt_dsh(
QEF_RCB *v_qer_p,
QEE_DSH *i_dsh_p)
{
DB_STATUS status = E_DB_OK;
QEF_CB *qecb_p = v_qer_p->qef_cb;
char *cbuf = v_qer_p->qef_cb->qef_trfmt;
i4 cbufsize = v_qer_p->qef_cb->qef_trsize;
if (TRUE)
return(E_DB_OK);
STprintf(cbuf,
"%s %p: ...1.1) Generic DSH information\n",
IIQE_61_qefsess,
(PTR) v_qer_p->qef_cb);
qec_tprintf(v_qer_p, cbufsize, cbuf);
status = qee_p1_dsh_gen(v_qer_p, i_dsh_p);
if (status)
return(status);
if (qecb_p->qef_c1_distrib & DB_3_DDB_SESS)
{
STprintf(cbuf,
"%s %p: ...1.2) DDB-specific DSH information\n",
IIQE_61_qefsess,
(PTR) v_qer_p->qef_cb);
qec_tprintf(v_qer_p, cbufsize, cbuf);
status = qee_p2_dsh_ddb(v_qer_p, i_dsh_p);
}
return(status);
}
bool
ascs_chk_priv( char *user_name, char *priv_name )
{
char pmsym[128], userbuf[DB_OWN_MAXNAME+1], *value, *valueptr ;
char *strbuf = 0;
int priv_len;
/*
** privileges entries are of the form
** ii.<host>.*.privilege.<user>: SERVER_CONTROL,NET_ADMIN,...
**
** Currently known privs are: SERVER_CONTROL,NET_ADMIN,
** MONITOR,TRUSTED
*/
STlcopy( user_name, userbuf, DB_OWN_MAXNAME );
STtrmwhite( userbuf );
STprintf(pmsym, "$.$.privileges.user.%s", userbuf);
/* check to see if entry for given user */
/* Assumes PMinit() and PMload() have already been called */
if( PMget(pmsym, &value) != OK )
return FALSE;
valueptr = value ;
priv_len = STlength(priv_name) ;
/*
** STindex the PM value string and compare each individual string
** with priv_name
*/
while ( *valueptr != EOS && (strbuf=STindex(valueptr, "," , 0)))
{
if (!STscompare(valueptr, priv_len, priv_name, priv_len))
return TRUE ;
/* skip blank characters after the ','*/
valueptr = STskipblank(strbuf+1, 10);
}
/* we're now at the last or only (or NULL) word in the string */
if ( *valueptr != EOS &&
!STscompare(valueptr, priv_len, priv_name, priv_len))
return TRUE ;
return FALSE;
}
/*
** close_log
*/
STATUS
close_log()
{
STATUS ret_val = OK ;
SYSTIME atime ;
char buffer [TEST_LINE] ;
char timestr [TEST_LINE] ;
append_line((char *)ERx("\n"),(i4)1);
TMnow(&atime);
TMstr(&atime,timestr);
STprintf(buffer,ERx("Ending at: %s"),timestr);
append_line(buffer,1);
SIclose(logptr);
return (ret_val);
}
STATUS
ERmsg_hdr( char *svr_id, SCALARP session, char *msg_header)
{
char host_name[65];
i4 length;
SYSTIME stime;
GChostname( host_name, sizeof( host_name ) );
STprintf( msg_header, "%-8.8s::[%-16.16s, %08.8x]: ",
host_name, svr_id, session );
TMnow(&stime);
TMstr(&stime,msg_header + STlength(msg_header));
length = STlength(msg_header);
msg_header[length++] = ' ';
msg_header[length] = EOS;
return (OK);
}
/* we need to use the shortest unique subset of the
** VMS pid for identifying temp files because of
** name length problems. -tw
*/
void
PCunique(
char *numb)
{
static char uniq_str[8] = "\0";
static bool got_uniq = FALSE;
PID numbuf;
if (!got_uniq)
{
PCpid(&numbuf);
numbuf &= 0177777; /* lower half is unique in VMS V3.x */
STprintf(uniq_str, "%x", numbuf);
got_uniq = TRUE;
}
STcopy(uniq_str, numb);
}
/*{
** Name: OPC_EEXCATTS - Build atts from eqcs that go to exchange
** buffer
**
** Description:
{@comment_line@}...
**
** Inputs:
[@PARAM_DESCR@]...
**
** Outputs:
[@PARAM_DESCR@]...
** Returns:
** {@return_description@}
** Exceptions:
** [@description_or_none@]
**
** Side Effects:
** [@description_or_none@]
**
** History:
** 13-nov-03 (inkdo01)
** Written for parallel query processing (cloned from opcsorts.c).
** 7-Apr-2004 (schka24)
** Set attr default stuff just in case someone looks at it.
[@history_template@]...
*/
static VOID
opc_eexatts(
OPS_STATE *global,
OPE_BMEQCLS *eeqcmp,
OPC_EQ *ceq,
DMF_ATTR_ENTRY ***patts, /* ptr to a ptr to an array of ptrs
to atts */
i4 *pacount )
{
OPS_SUBQUERY *subqry = global->ops_cstate.opc_subqry;
DMF_ATTR_ENTRY **atts;
DMF_ATTR_ENTRY *att;
i4 attno;
OPZ_AT *at = global->ops_cstate.opc_subqry->ops_attrs.opz_base;
OPE_IEQCLS eqcno;
*pacount = BTcount((char *)eeqcmp, (i4)subqry->ops_eclass.ope_ev);
if (*pacount == 0)
return; /* count(*) or sommat - no atts to materialize */
atts = (DMF_ATTR_ENTRY **) opu_qsfmem(global,
*pacount * sizeof (DMF_ATTR_ENTRY *));
for (attno = 0, eqcno = -1;
(eqcno = BTnext((i4)eqcno, (char *)eeqcmp,
(i4)subqry->ops_eclass.ope_ev)) != -1;
attno += 1
)
{
att = (DMF_ATTR_ENTRY *) opu_qsfmem(global, sizeof (DMF_ATTR_ENTRY));
STprintf(att->attr_name.db_att_name, "a%x", eqcno);
STmove(att->attr_name.db_att_name, ' ',
sizeof(att->attr_name.db_att_name), att->attr_name.db_att_name);
att->attr_type = ceq[eqcno].opc_eqcdv.db_datatype;
att->attr_size = ceq[eqcno].opc_eqcdv.db_length;
att->attr_precision = ceq[eqcno].opc_eqcdv.db_prec;
att->attr_flags_mask = 0;
SET_CANON_DEF_ID(att->attr_defaultID, DB_DEF_NOT_DEFAULT);
att->attr_defaultTuple = NULL;
atts[attno] = att;
}
*patts = atts;
}
/*{
** Name: II_GetErrorMessage
**
** Description:
** Returns the associated error message for the error status.
**
** Inputs:
** status Error status.
** errmsg Area to be updated with message text. The maximum length,
** in octets, of a returned message is MAX_IIERR_LEN and
** does not include the end-of-string marker.
** The minimum size of this area should be
** (MAX_IIERR_LEN + 1).
**
** Outputs:
** errmsg Error text. If the message text exceeds MAX_IIERR_LEN
** then the message is truncated to MAX_IIERR_LEN.
**
** Returns:
** None.
**
** Example:
** # include "tngapi.h"
**
** II_CHAR errmsg[ MAX_IIERR_LEN + 1] = {'\0'};
** II_INT status = II_NULL_PARAM;
**
** II_GetErrorMessage( status, errmsg );
** printf( "Error message =%s\n", errmsg );
**
** History:
** 24-Jun-2002 (fanra01)
** Created.
**
}*/
void
II_GetErrorMessage( II_UINT4 status, char* errmsg )
{
char errormessage[ MAX_IIERR_LEN + 1 ] = { 0 };
#if defined(NT_GENERIC)
char* p = errormessage;
int nlen = 0;
if (errmsg)
{
if (hModule == NULL)
{
hModule = GetModuleHandle( II_MODULENAME );
}
if (hModule != NULL)
{
FormatMessage(
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_FROM_HMODULE |
FORMAT_MESSAGE_IGNORE_INSERTS,
(LPCVOID)hModule,
status,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
(LPTSTR) errormessage,
MAX_IIERR_LEN,
NULL
);
STlcopy( errormessage, errmsg, MAX_IIERR_LEN );
}
}
#else /* NT_GENERIC */
/* Here is for Unix platforms , Send back error message to the caller */
if( status != OK )
{
STprintf( errormessage, ERget(status) );
SIfprintf( stderr, errormessage );
STlcopy( errormessage, errmsg, STlength(errormessage) );
}
#endif
return;
}
void
main(int argc, char *argv[])
{
#define MAXBUF 4095
char buf[ MAXBUF+1 ];
int iarg, ibuf, ichr;
/*
* Put the program name and first parameter in the buffer.
*/
STprintf(buf, ERx( "dmfjsp relocdb" ));
switch(argc)
{
case 1:
break;
/*
* Append any args from the command line, e.g.,
* dmfjsp relocdb -new_ckp_location dbname
*/
default:
ibuf = sizeof(ERx("dmfjsp relocdb")) - 1;
for (iarg = 1; (iarg < argc) && (ibuf < MAXBUF); iarg++) {
buf[ibuf++] = ' ';
for (ichr = 0;
(argv[iarg][ichr] != '\0') && (ibuf < MAXBUF);
ichr++, ibuf++)
buf[ibuf] = argv[iarg][ichr];
}
buf[ibuf] = '\0';
}
/*
* Execute the command.
*/
if( PCexec_suid(&buf) != OK )
PCexit(FAIL);
PCexit(OK);
}
void
main(int argc, char *argv[])
{
char buf[ MAXBUF+1 ];
int ibuf, ichr;
/*
** Set the set command.
*/
STprintf(buf, ERx( "@set " ));
switch(argc)
{
/*
** Construct the rest of the command from the
** command line argument and standard input.
*/
case 2:
ibuf = sizeof(ERx("@set ")) - 1;
for ( ichr = 0 ;(ibuf < MAXBUF) && argv[1][ichr]; )
{
buf[ibuf++] = argv[1][ichr++];
}
buf[ibuf++] = '=';
/*
** Set EOS in case there is nothing from standard input.
*/
buf[ibuf] = '\0';
SIgetrec(&buf[ibuf], MAXBUF-ibuf, stdin);
break;
default:
SIprintf(stderr,"echo Usage: ipsetp variable_name");
break;
}
/*
** Print out the set command.
*/
SIprintf("%s\n",buf);
}
void
main(int argc, char *argv[])
{
#define MAXBUF 4095
char buf[ MAXBUF+1 ];
int iarg, ibuf, ichr;
/*
* Put the program name and first parameter in the buffer.
*/
STprintf(buf, ERx( "esqlc -cplusplus -extension=cpp" ));
switch(argc)
{
case 1:
break;
/*
* Append any args from the command line, e.g.,
* esqlc -cplusplus -extension=EXT [files]
*/
default:
ibuf = sizeof(ERx("esqlc -cplusplus -extension=cpp")) - 1;
for (iarg = 1; (iarg < argc) && (ibuf < MAXBUF); iarg++) {
buf[ibuf++] = ' ';
for (ichr = 0;
(argv[iarg][ichr] != '\0') && (ibuf < MAXBUF);
ichr++, ibuf++)
buf[ibuf] = argv[iarg][ichr];
}
buf[ibuf] = '\0';
}
/*
* Execute the command.
*/
if( execute(buf) != OK )
PCexit(FAIL);
PCexit(OK);
}
void
rfapi_getDateTime( char *dtbuf )
{
SYSTIME tm; /* system time in seconds */
struct TMhuman dthuman; /* human readable date and time structure */
/* get the system time */
TMnow( &tm );
/* break it up into human readable format */
TMbreak( &tm, &dthuman );
STprintf( dtbuf, RFAPI_DATE_FORMAT,
dthuman.wday,
dthuman.month,
dthuman.day,
dthuman.hour,
dthuman.mins,
dthuman.sec,
dthuman.year );
}
