/* ** ** 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); }