/*
**
** Name: ex_print_error() - print ex message to errlog.log
**
** Description:
** Function passed to CS_dump_stack to print message to errlog.log.
** Called through TRformat hence first argument is a dummy for us.
**
** Inputs:
** arg1 ignored.
** msg_length length of message.
** msg_buffer bufer for message.
**
** Returns:
** void
**
** History:
** 05-dec-1995 (whitfield)
** Integrated from VAX version of exsysrep.
** 07-dec-1995 (whitfield)
** Use ANSI fn definitions.
** 24-jan-1996 (dougb)
** Remove TRdisplay() call. Correct ERsend() parameters.
** 11-jun-1998 (kinte01)
** Cross integrate change 435890 from oping12
** 19-may-1998 (horda03) X-Integrate Change 427896.
** 03-Oct-1996 (mckba02)
** Add call to EXdump(), for diags + call to cs_dump_stack
** for general error log diagnostics.
** 19-jul-2000 (kinte01)
** Correct prototype definitions by adding missing includes and
** add external function references
** 01-dec-2000 (kinte01)
** Bug 103393 - removed nat, longnat, u_nat, & u_longnat
** from VMS CL as the use is no longer allowed
** 07-sep-2010 (joea)
** For i64_vms, move EXsetclient to exsignal.c.
** 06-Dec-2010 (horda03) SIR 124685
** Fix VMS build problems,
*/
static STATUS
ex_print_error(PTR arg1, i4 msg_length, char *msg_buffer)
{
CL_ERR_DESC err_code;
ERsend( ER_ERROR_MSG, msg_buffer, msg_length, &err_code );
return (OK);
}
int
main(int c, char **v)
{
i4 msg_id;
i4 cnt = 0;
char mbuf[ER_MAX_LEN];
i4 ret_len = 0;
char msgbuf[101];
CL_ERR_DESC clerror;
CL_ERR_DESC err_code;
STATUS stat;
i4 flag = 0;
bool testsysdep = FALSE;
bool logoper = FALSE;
MEadvise(ME_INGRES_ALLOC);
for (++v, --c; c > 0; ++v, --c)
{
char *w = *v;
if (w[0] == '-')
{
switch (w[1])
{
case 't':
flag |= ER_TIMESTAMP;
break;
case 'n':
flag |= ER_NOPARAM;
break;
case 's':
testsysdep = TRUE;
break;
case 'o':
logoper = TRUE;
break;
default:
SIfprintf(stderr, "only valid options are -t, -s, -n and -o\n");
PCexit(FAIL);
}
}
else
SIfprintf(stderr, "ignoring invalid argument \"%s\"\n", v);
}
if (testsysdep) /* test system dependent error reporting */
{
extern int errno;
errno = 13; /* EACCES */
SETCLERR(&clerror, 0x10911, /* ER_INTERR_TESTMSG */ ER_open);
STcopy("II_MSGDIR/erclf.msg", clerror.moreinfo[0].data.string);
clerror.moreinfo[0].size = STlength(clerror.moreinfo[0].data.string);
}
while ((cnt++) < MAX_NUM_OF_LOOKUPS)
{
msg_id = -1;
SIfprintf(stderr, "msg id, in hex, no 0x%s: ",
testsysdep? " (try 10904) " : "");
if( OK != SIgetrec(msgbuf, 100, stdin) )
break;
#if defined(any_aix) && defined(BUILD_ARCH64)
(VOID) STscanf(msgbuf, "%x", &msg_id);
#else
(VOID) STscanf(msgbuf, "%p", &msg_id);
#endif
if (msg_id == -1)
break;
if ((stat = ERslookup(msg_id, testsysdep? &clerror : NULL, flag,
(char *) NULL, mbuf, ER_MAX_LEN, -1, &ret_len, &err_code, 5,
er_arg)) != OK)
{
SIfprintf(stderr,
"ERslookup error. msg id is 0x%x, status is 0x%x\n",
msg_id, stat);
}
else
{
SIfprintf(stderr, "*** ERslookup:\n%s\n", mbuf);
SIfprintf(stderr, "*** ERget:\n%s\n", ERget(msg_id));
}
if (testsysdep)
{
if ((stat = ERslookup(0, &clerror, flag, (char *) NULL, mbuf,
ER_MAX_LEN, -1, &ret_len, &err_code, 5, er_arg)) != OK)
{
SIfprintf(stderr,
"ERslookup error on CL_ERR_DESC. Status is 0x%x\n", stat);
}
else
SIfprintf(stderr, "*** ERslookup (CL error):\n%s\n",mbuf);
}
if (logoper)
{
ERsend( ER_ERROR_MSG|ER_OPER_MSG, mbuf, ret_len, &err_code );
}
}
PCexit(OK);
}
DB_STATUS
uleFormatFcn(
DB_ERROR *dberror,
i4 err_code,
CL_ERR_DESC *clerror,
i4 flag,
DB_SQLSTATE *sqlstate,
char *msg_buffer,
i4 msg_buf_length,
i4 *msg_length,
i4 *uleError,
PTR uleFileName,
i4 uleLineNumber,
i4 num_parms,
... )
{
#define NUM_ER_ARGS 12
struct {
ULE_MHDR hdr;
/* FIX ME should message size be ER_MAX_LEN - sizeof(ULE_MHDR) */
char message[ER_MAX_LEN];
} buffer;
i4 i;
i4 length = 0;
i4 text_length;
i4 status;
CL_ERR_DESC sys_err;
i4 language;
SCF_SESSION sid;
SCF_SCI info[10];
SCF_CB scf_cb;
ER_ARGUMENT er_args[NUM_ER_ARGS];
char hex_chars[16] = {'0','1','2','3','4','5','6','7',
'8','9','a','b','c','d','e','f'};
i4 error_code;
i4 local_error_code;
DB_ERROR localDBerror, *DBerror;
PTR FileName;
i4 LineNumber;
char *qbuf = NULL;
char *prev_qbuf = NULL;
char *psqbuf = NULL;
i4 qlen = 0;
i4 prev_qlen = 0;
i4 psqlen = 0;
i4 trace_errno = 0;
i4 trace_stack = 0;
i4 prlen;
char *prbuf;
i2 hdr_size;
i4 NumParms;
va_list ap;
LOCATION loc;
char dev[LO_NM_LEN];
char fprefix[LO_NM_LEN];
char fsuffix[LO_NM_LEN];
char version[LO_NM_LEN];
char path[MAX_LOC + 1];
char filebuf[MAX_LOC + 1];
char LineNo[LO_NM_LEN];
char *MessageArea = (char*)&buffer.message;
char SourceInfo[LO_NM_LEN];
i4 PrefixLen = sizeof(ULE_MHDR);
if (Ule_started == 0)
{
MEfill(sizeof(ULE_MHDR), (u_char)' ', (PTR)&Ule_mhdr);
Ule_started = -1;
}
/*
** If old form (no dberror) or overriding err_code,
** use caller's err_code, File, and Line information,
** otherwise use what's in "dberror".
*/
if ( !dberror || err_code )
{
DBerror = &localDBerror;
DBerror->err_file = uleFileName;
DBerror->err_line = uleLineNumber;
DBerror->err_code = err_code;
DBerror->err_data = 0;
/* Fill caller's dberror with that used */
if ( dberror )
*dberror = *DBerror;
}
else
DBerror = dberror;
error_code = local_error_code = DBerror->err_code;
MessageArea = (char*)&buffer.message;
info[0].sci_code = SCI_SID;
info[0].sci_length = sizeof(sid);
info[0].sci_aresult = (char *) &sid;
info[0].sci_rlength = 0;
info[1].sci_code = SCI_LANGUAGE;
info[1].sci_length = sizeof(language);
info[1].sci_aresult = (char *) &language;
info[1].sci_rlength = 0;
scf_cb.scf_length = sizeof(SCF_CB);
scf_cb.scf_type = SCF_CB_TYPE;
scf_cb.scf_ascii_id = SCF_ASCII_ID;
scf_cb.scf_facility = DB_ULF_ID;
scf_cb.scf_session = DB_NOSESSION;
scf_cb.scf_len_union.scf_ilength = 2;
scf_cb.scf_ptr_union.scf_sci = (SCI_LIST *) &info[0];
/* scf_error is not usually an input parameter */
if (flag == ULE_LOG || flag == ULE_MESSAGE)
{
info[2].sci_code = SCI_QBUF;
info[2].sci_length = sizeof(qbuf);
info[2].sci_aresult = (char *) &qbuf;
info[2].sci_rlength = 0;
info[3].sci_code = SCI_QLEN;
info[3].sci_length = sizeof(qlen);
info[3].sci_aresult = (char *) &qlen;
info[3].sci_rlength = 0;
info[4].sci_code = SCI_TRACE_ERRNO;
info[4].sci_length = sizeof(trace_errno);
info[4].sci_aresult = (char *) &trace_errno;
info[4].sci_rlength = 0;
info[5].sci_code = SCI_PREV_QBUF;
info[5].sci_length = sizeof(prev_qbuf);
info[5].sci_aresult = (char *) &prev_qbuf;
info[5].sci_rlength = 0;
info[6].sci_code = SCI_PREV_QLEN;
info[6].sci_length = sizeof(prev_qlen);
info[6].sci_aresult = (char *) &prev_qlen;
info[6].sci_rlength = 0;
info[7].sci_code = SCI_PSQ_QBUF;
info[7].sci_length = sizeof(psqbuf);
info[7].sci_aresult = (char *) &psqbuf;
info[7].sci_rlength = 0;
info[8].sci_code = SCI_PSQ_QLEN;
info[8].sci_length = sizeof(psqlen);
info[8].sci_aresult = (char *) &psqlen;
info[8].sci_rlength = 0;
info[9].sci_code = SCI_TRACE_STACK;
info[9].sci_length = sizeof(trace_stack);
info[9].sci_aresult = (char *) &trace_stack;
info[9].sci_rlength = 0;
scf_cb.scf_len_union.scf_ilength = 10;
}
status = scf_call(SCU_INFORMATION, &scf_cb);
if (status)
{
language = 1;
sid = 0;
}
if (!language)
language = 1;
/* package up the stack parameters into an ER_ARGUMENT array */
va_start( ap, num_parms );
for( NumParms = 0; NumParms < num_parms && NumParms < NUM_ER_ARGS; NumParms++ )
{
er_args[NumParms].er_size = (i4) va_arg( ap, i4 );
er_args[NumParms].er_value = (PTR) va_arg( ap, PTR );
}
va_end( ap );
*uleError = 0;
if (flag == 0 || flag == ULE_LOG || flag == ULE_LOOKUP)
{
/* Get INGRES message text. */
status = ERslookup( local_error_code,
CLERROR(local_error_code)? clerror : (CL_ERR_DESC*) NULL,
ER_TIMESTAMP,
(sqlstate) ? sqlstate->db_sqlstate : (char *) NULL,
MessageArea,
(i4) sizeof(buffer.message),
(i4) language,
&text_length,
&sys_err,
NumParms,
er_args
);
if (status != OK)
{
CL_ERR_DESC junk;
STprintf(MessageArea, "ULE_FORMAT: ");
length = STlength(MessageArea);
/*
** If uleFormat caller is different than
** error source, identify caller.
*/
if ( flag == ULE_LOG && uleFileName &&
(uleFileName != DBerror->err_file ||
uleLineNumber != DBerror->err_line) )
{
STcopy(uleFileName, filebuf);
STprintf(LineNo, ":%d ", uleLineNumber);
if ( LOfroms(PATH & FILENAME, filebuf, &loc) ||
LOdetail(&loc, dev, path, fprefix, fsuffix, version) )
{
STpolycat(2, FileName,
LineNo,
&MessageArea[length]);
}
else
{
STpolycat(4, fprefix,
".", fsuffix,
LineNo,
&MessageArea[length]);
}
length = STlength(MessageArea);
MessageArea[length++] = ' ';
}
STprintf(&MessageArea[length],
"Couldn't look up message %x ",
local_error_code);
length = STlength(MessageArea);
STprintf(&MessageArea[length], "(reason: ER error %x)\n",status);
length = STlength(MessageArea);
status = ERslookup( (i4) status,
&sys_err,
(i4) 0,
(sqlstate) ? sqlstate->db_sqlstate
: (char *) NULL,
&MessageArea[length],
(i4) (sizeof(buffer.message) - length),
(i4) language,
&text_length,
&junk,
0,
(ER_ARGUMENT *) NULL
);
if (status != OK)
{
STprintf(&MessageArea[length],
"... ERslookup failed twice: status = %x", status);
length = STlength(MessageArea);
}
else
{
length += text_length;
}
*uleError = E_UL0002_BAD_ERROR_LOOKUP;
}
else
{
length = text_length;
}
/* Get system message text. */
if (clerror)
{
MessageArea[length++] = '\n';
/*
** Extract the distinct clerror source information, filename,
** extension, and line number from CL_ERR_DESC
** and prefix the message text with it.
*/
if ( !CLERROR(error_code) && (FileName = clerror->errfile) )
{
STcopy(FileName, filebuf);
STprintf(LineNo, ":%d ", clerror->errline);
if ( LOfroms(PATH & FILENAME, filebuf, &loc) ||
LOdetail(&loc, dev, path, fprefix, fsuffix, version) )
{
STpolycat(2, FileName,
LineNo,
&MessageArea[length]);
}
else
{
STpolycat(4, fprefix,
".", fsuffix,
LineNo,
&MessageArea[length]);
}
length += STlength(&MessageArea[length]);
MessageArea[length++] = ' ';
}
status = ERslookup( (i4) 0,
clerror,
(i4) 0,
(sqlstate) ? sqlstate->db_sqlstate
: (char *) NULL,
&MessageArea[length],
(i4) (sizeof(buffer.message) - length),
(i4) language,
&text_length,
&sys_err,
0,
(ER_ARGUMENT *) NULL
);
if (status != OK)
{
CL_ERR_DESC junk;
STprintf(&MessageArea[length],
"ULE_FORMAT: Couldn't look up system error ");
length = STlength(MessageArea);
STprintf(&MessageArea[length],
"(reason: ER error %x)\n", status);
length = STlength(MessageArea);
status = ERslookup( (i4) status,
&sys_err,
(i4) 0,
(sqlstate) ? sqlstate->db_sqlstate
: (char *) NULL,
&MessageArea[length],
(i4) (sizeof(buffer.message) - length),
(i4) language,
&text_length,
&junk,
0,
(ER_ARGUMENT *) NULL
);
if (status != OK)
{
STprintf(&MessageArea[length],
"... ERslookup failed twice: status = %x", status);
length = STlength(MessageArea);
}
else
{
length += text_length;
}
*uleError = E_UL0001_BAD_SYSTEM_LOOKUP;
}
else
{
length += text_length;
}
}
/* Copy into callers buffer if requested. */
if (msg_buffer && msg_buf_length)
{
if (msg_buf_length < length)
length = msg_buf_length;
MEcopy((PTR)MessageArea, length, (PTR)msg_buffer);
*msg_length = length;
}
}
else if (flag == ULE_MESSAGE)
{
if (!msg_buffer || !msg_buf_length)
{
*uleError = E_UL0003_BADPARM;
return (E_DB_ERROR);
}
MEcopy((PTR)msg_buffer, msg_buf_length, (PTR)MessageArea);
length = msg_buf_length;
}
if (flag == ULE_LOG || flag == ULE_MESSAGE)
{
SCF_SESSION tmp_sid = sid;
MEcopy((PTR)&Ule_mhdr, sizeof(ULE_MHDR), (PTR)&buffer.hdr);
for (i = (sizeof(Ule_mhdr.ule_session)) ; --i >= 0; )
{
buffer.hdr.ule_session[i] = hex_chars[(tmp_sid & 0xf)];
tmp_sid >>= 4;
}
/*
** Extract the error source information, filename, extension,
** and line number from CL_ERR_DESC or DB_ERROR
** and format it into the ULE_MHDR.
*/
if ( CLERROR(DBerror->err_code) && clerror && clerror->errfile )
{
FileName = clerror->errfile;
LineNumber = clerror->errline;
}
else
{
FileName = DBerror->err_file;
LineNumber = DBerror->err_line;
}
if ( FileName )
{
STprintf(LineNo, ":%d ", LineNumber);
STcopy(FileName, filebuf);
if ( LOfroms(PATH & FILENAME, filebuf, &loc) ||
LOdetail(&loc, dev, path, fprefix, fsuffix, version) )
{
STpolycat(2, FileName,
LineNo,
SourceInfo);
}
else
{
STpolycat(4, fprefix,
".", fsuffix,
LineNo,
SourceInfo);
}
STmove(SourceInfo, ' ', SourceInfoLen, (PTR)&buffer.hdr.ule_source);
}
/* Echo the message to II_DBMS_LOG, if defined */
TRwrite(NULL, PrefixLen + length, (PTR)&buffer);
status = ERsend(ER_ERROR_MSG, (PTR)&buffer,
PrefixLen + length, &sys_err);
}
